SSD Nodes Learn Hosting plans →

Agent skills, MCP servers, rules files: எது சிறந்தது?

Coding agent-க்கு context வழங்க உதவும் Agent skills, MCP servers மற்றும் rules files ஆகியவற்றின் பயன்பாடு மற்றும் token செலவுகளை ஒப்பிட்டு, உங்கள் தேவைக்கு ஏற்றதை தேர்வு செய்யுங்கள்.

Agent skills, MCP servers மற்றும் rules files: சுருக்கமான விளக்கம்

Agent skills, MCP servers மற்றும் rules files ஆகிய மூன்றும் ஒரு coding agent-க்குத் தேவையான தகவல்களை வழங்குகின்றன. அந்தத் தகவல் என்ன செய்கிறது என்பதைப் பொறுத்து எதைத் தேர்ந்தெடுக்க வேண்டும் என்பதை முடிவு செய்யுங்கள். MCP (model context protocol) என்பது நீங்கள் அடுத்த முறை பார்க்கும்போது மாறக்கூடிய தரவுகளுக்கானது. ஒரு skill என்பது, இன்று நீங்கள் எழுதி வைத்துவிட்டு ஆறு வாரங்கள் கழித்துப் பார்த்தாலும் சரியாக இருக்கக்கூடிய நடைமுறைகளுக்கானது. ஒரு rules file என்பது ஒவ்வொரு session-லும் மாறாமல் இருக்க வேண்டிய சில அடிப்படை உண்மைகளுக்கானது.

இந்தத் தேர்வுக்கு ஒரு விலை உண்டு, அந்த விலை context ஆகும். Agent-க்குத் தேவையில்லாத ஒரு instruction-க்காகச் செலவிடப்படும் ஒவ்வொரு token-ம், அது வாசிக்கும் code-க்காகப் பயன்படுத்த முடியாத ஒன்றாகிறது. மேலும், ஒவ்வொரு turn-லும் முழு context window-ம் மீண்டும் அனுப்பப்படுவதால், அந்த token-க்கான கட்டணத்தை நீங்கள் மீண்டும் மீண்டும் செலுத்துகிறீர்கள். எனவே, எந்த நுட்பத்தால் வேலையைச் செய்ய முடியும் என்பது சரியான கேள்வி அல்ல. பெரும்பாலான நாட்களில் மூன்றையுமே பயன்படுத்த முடியும். எந்த நுட்பம் பயன்பாட்டில் இல்லாதபோது குறைந்த செலவை (cost) ஏற்படுத்துகிறது என்பதே சரியான கேள்வி.

பயன்படுத்துவதற்கு முன்பு ஒவ்வொன்றின் செலவு

மூன்றும் வெவ்வேறு தருணங்களில் ஏற்றப்படுகின்றன, அந்த நேரமே முழு வித்தியாசத்தையும் ஏற்படுத்துகிறது.

நிபந்தனையற்ற விதிகள் கோப்பு (unconditional rules file) தொடக்கத்தின்போது, ஒவ்வொரு அமர்விலும், அது தொடர்புடையதாக இருந்தாலும் இல்லாவிட்டாலும், தவிர்க்கப்படாவிட்டால் ஏற்றப்படும். Claude Code ஒவ்வொரு உரையாடலின் தொடக்கத்திலும் CLAUDE.md கோப்புகளைப் படிக்கிறது, குறியீட்டுத் தொகுதிகளுக்கு (code blocks) வெளியே உள்ள block-level HTML கருத்துகளை நீக்கிவிட்டு அவற்றின் உள்ளடக்கத்தைச் சேர்க்கிறது, மேலும் 4 MiB-க்கு மேல் உள்ள கோப்புகளைத் தவிர்க்கிறது; claudeMdExcludes மூலம் நிர்வகிக்கப்படும் கொள்கைக் கோப்பைத் தவிர மற்ற கோப்புகளைத் தவிர்க்க முடியும். ஆவணப்படுத்தப்பட்ட இலக்கு ஒரு கோப்பிற்கு 200 வரிகளுக்குக் குறைவாக இருக்க வேண்டும், ஏனெனில் நீண்ட கோப்பு அதிக context-ஐச் செலவழிப்பதுடன், குறைவாகவே பின்பற்றப்படுகிறது. இந்த இரண்டு விளைவுகளும் ஒரே மாதிரியானவை, அதனால்தான் 900-வரி விதிகள் கோப்பு பயனற்றதை விட மோசமானது.

ஒரு திறன் (skill) இரண்டு நிலைகளில் ஏற்றப்படுகிறது. தொடக்கத்தின்போது ஒவ்வொரு SKILL.md frontmatter-லிருந்து description வரி மட்டுமே context-க்குள் நுழைகிறது, எனவே அந்தத் திறன் இருப்பதை model அறியும் மற்றும் அது எப்போது பொருந்தும் என்பதைத் தோராயமாக அறியும். திறன் அழைக்கப்படும்போது அதன் உடல் (body) ஏற்றப்படுகிறது. எனவே, 400-வரி குறிப்பு ஆவணம் தேவைப்படும் தருணம் வரை உங்களுக்கு எதையும் செலவழிப்பதில்லை.

ஒரு MCP server முன்பு அதிக செலவு கொண்டதாக இருந்தது, நீங்கள் படிக்கும் பெரும்பாலான ஒப்பீடுகள் இப்போது காலாவதியானவை. தற்போதைய Claude Code-ல் tool search இயல்பாகவே ஆன் செய்யப்பட்டுள்ளது. அமர்வின் தொடக்கத்தில் கருவியின் பெயர்கள் மற்றும் server-ன் instructions புலம் மட்டுமே ஏற்றப்படுகின்றன, மேலும் முழு JSON (JavaScript object notation) schemas-ம் Claude அவற்றைத்தேடும் வரை ஒத்திவைக்கப்படுகின்றன. ஒரு server-ஐச் சேர்ப்பது இனி ஆயிரக்கணக்கான tokens-ஐ முன்கூட்டியே செலவழிப்பதில்லை. இது இன்னும் சில செலவுகளைக் கொண்டுள்ளது, மேலும் tool search ஆஃப் செய்யப்பட்டுள்ள configurations-ல் இது இன்னும் முன்கூட்டியே அனைத்தையும் செலவழிக்கிறது.

விளக்கப்படம்Startup and post-use context cost, estimated tokens
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "label": "Rules file, 200 lines",
    "at_startup": "2,500",
    "after_use": "2,500"
  },
  {
    "label": "Skill, 12 KB body",
    "at_startup": 40,
    "after_use": "3,000"
  },
  {
    "label": "MCP server, tool search on",
    "at_startup": 500,
    "after_use": "3,200"
  },
  {
    "label": "MCP server, tool search off",
    "at_startup": "4,500",
    "after_use": "4,500"
  }
]

இவை உங்கள் கணினியிலிருந்து எடுக்கப்பட்ட அளவீடுகள் அல்ல, மதிப்பீடுகள் மட்டுமே. இவை ஒவ்வொரு பொறிமுறையும் ஏற்றும் உரையின் அளவிலிருந்து வருகின்றன, ஒரு token-க்கு தோராயமாக நான்கு எழுத்துகள் வீதம்: 200-வரி விதிகள் கோப்பு சுமார் 10 KB markdown, ஒரு திறன் விளக்கம் சுமார் 160 எழுத்துகள், மற்றும் பன்னிரண்டு கருவிகளை வெளிப்படுத்தும் ஒரு server சுமார் 18 KB schema மற்றும் 2 KB instructions தொகுதியைக் கொண்டுள்ளது. Claude Code, server instructions புலத்தையும், முன்கூட்டியே ஏற்றப்படும் ஒவ்வொரு கருவியின் விளக்கத்தையும் இயல்பாக 4,096 எழுத்துகளாகக் குறைக்கிறது, மேலும் tool search மூலம் ஏற்றப்படும் கருவி விளக்கம் 16,384 எழுத்துகளாகக் குறைக்கப்படுகிறது. v2.1.296-க்கு முன்பு குறைந்தபட்ச வரம்பு 2,048 எழுத்துகளாக இருந்தது, நீங்கள் அதை அமைத்தால் CLAUDE_CODE_MAX_MCP_DESCRIPTION_LENGTH அந்த இரண்டு வரம்புகளையும் மாற்றுகிறது. சில Anthropic-hosted MCP server-களிலிருந்து வரும் instructions மற்றும் விளக்கங்கள் அந்த variable அமைக்கப்பட்டிருந்தாலும் Claude-ஐ முழுமையாகச் சென்றடைகின்றன, எனவே இந்த வரம்புகள் உலகளாவிய உச்சவரம்பு அல்ல. அடுத்த பகுதி உங்கள் சொந்த உண்மையான எண்களை எவ்வாறு படிப்பது என்பதைக் காட்டுகிறது.

முதல் இரண்டு வரிசைகளை ஒன்றாகப் படிக்கவும். விதிகள் கோப்பு, யாருக்கும் தேவைப்படாத அமர்வில் 2,500 tokens-ஐச் செலவழிக்கிறது. அதே அமர்வில் திறன் 40 tokens-ஐயும், அது செயல்படும் பத்து அமர்வுகளில் ஒன்றில் 3,000 tokens-ஐயும் செலவழிக்கிறது. கடைசி இரண்டு வரிசைகள் ஒரே server-ஐ இரண்டு முறை காட்டுகின்றன, tool search ஆன் மற்றும் ஆஃப் நிலையில்: 500 tokens மற்றும் 4,500. அந்த இடைவெளிதான் MCP context bloat பற்றிய பழைய ஆலோசனைகள் இன்னும் பரவுவதற்குக் காரணம்.

அக்டோபர் 2026 நிலவரப்படி, Claude Code ஆனது Claude Opus 4, Sonnet 4, Haiku 4.5 மற்றும் அதற்குப் பிந்தைய model-களிலும், Google Cloud-ன் Agent Platform-ல் Opus 4.5, Sonnet 4.5, Haiku 4.5 மற்றும் அதற்குப் பிந்தைய model-களிலும் tool search-ஐப் பயன்படுத்துகிறது. பழைய model-களிலும், Azure-ல் ஹோஸ்ட் செய்யப்பட்ட Microsoft Foundry deployments-லும், நீங்கள் எதை அமைத்தாலும் ஒவ்வொரு MCP கருவியும் முன்கூட்டியே ஏற்றப்படும். LLM gateway-ஐக் குறிக்கும் ANTHROPIC_BASE_URL உடன், v2.1.304 முதல் tool search இயல்பாகவே ஆன் செய்யப்பட்டுள்ளது; பழைய பதிப்புகள் நீங்கள் தேர்வு செய்யாவிட்டால் அதை ஆஃப் செய்தன. v2.1.305 முதல், 400 அல்லது 422-க்குப் பிறகு tool search இல்லாமல் gateway கோரிக்கையை Claude Code மீண்டும் முயற்சி செய்ய முடியும், அந்த மறுமுயற்சி வெற்றிபெறும்போது கருவிகளை முன்கூட்டியே ஏற்றும். இதைக் கட்டுப்படுத்த ENABLE_TOOL_SEARCH-ஐ அமைக்கவும்: false ஒவ்வொரு schema-வையும் முன்கூட்டியே ஏற்றுகிறது, true அதை அமைக்காமல் விடுவது போன்ற அதே model மற்றும் deployment fallbacks-உடன் அவற்றை ஒத்திவைக்கிறது, மேலும் auto அவற்றின் வரையறைகள் context window-ல் 10%-க்குக் குறைவாக இருக்கும் வரை முன்கூட்டியே ஏற்றுகிறது, பின்னர் அந்த வரம்பை எட்டிய பிறகு, மொத்த அளவு அதற்குக்கீழ் குறைந்தாலும் tool search-ஐ ஆன் நிலையில் வைத்திருக்கும். "alwaysLoad": true உடன் கட்டமைக்கப்பட்ட ஒரு server, ENABLE_TOOL_SEARCH-ஐப் பொருட்படுத்தாமல் அதன் கருவிகளை முன்கூட்டியே ஏற்றுகிறது.

# Load schemas up front only if they fit in 5% of the window
ENABLE_TOOL_SEARCH=auto:5 claude

தீர்மானிக்கும் கேள்வி: ஒவ்வொரு முறை இயக்கும்போதும் தரவு மாறுகிறதா?

முதலில் இந்தக் கேள்வியைக் கேளுங்கள், ஏனெனில் இது ஒரு விருப்பத்தை உடனடியாக நீக்கிவிடும். ஏஜென்ட் (agent) அடுத்த முறை பார்க்கும்போது மாறக்கூடிய ஒன்றை வாசிக்கவோ அல்லது எழுதவோ வேண்டியிருந்தால், உங்களுக்கு ஒரு server தேவை. ஒரு issue tracker, database, monitoring dashboard, அல்லது உங்களின் சொந்த internal API (application programming interface) போன்றவை இதற்கு உதாரணம். தரவை ஒரு கோப்பில் எழுதி வைப்பது உதவாது, ஏனெனில் வேறொருவர் அந்தப் பதிவைத் திருத்திய அடுத்த நொடியே நீங்கள் எழுதியது காலாவதியாகிவிடும். உங்களின் சொந்த codebase-ம் இந்த பட்டியலில் சேரும், ஏனெனில் ஒவ்வொரு commit-ன் போதும் அதன் கட்டமைப்பு மாறுகிறது. இதனால்தான் repository-ன் parsed map-ஐ MCP வழியாக ஏஜென்ட்டிற்கு வழங்குவது சிறந்தது; மாறாக, காலாவதியாகக்கூடிய ஒரு கோப்பில் அதன் அமைப்பை விவரிப்பது சரியானதல்ல.

யாரும் பராமரிக்காத நிலையிலும் ஆறு வாரங்களுக்குப் பிறகும் அந்தப் பதில் சரியாகவே இருக்கும் என்றால், உங்களுக்கு ஒரு skill தேவை. ஒரு release checklist, migration procedure, error responses-ன் வடிவம், அல்லது இந்த repository-ல் சோதனைகள் (tests) எவ்வாறு எழுதப்பட வேண்டும் என்பது போன்றவை இதற்கு உதாரணம். ஒரு skill என்பது git-ல் உள்ள ஒரு கோப்பு. இதற்கு port கிடையாது, process கிடையாது, தவறாக இருப்பதைத் தவிர வேறு தோல்வி நிலைகளும் (failure mode) கிடையாது; அதை ஒரு code review மூலம் கண்டறியலாம்.

நீங்கள் இன்னும் சிந்திக்காத பணிகளுக்கும் பொருந்தக்கூடிய ஒரு உண்மை என்றால், அதை rules கோப்பில் பதிவிடுங்கள். Run make lint before committing. Never push to main. Handlers live in src/api/handlers/. ஒவ்வொன்றையும் தனித்தனி வரியில் எழுதவும். ஒரு குறிப்பு பல படிகளைக் கொண்டதாக மாறினால், அது உண்மையாக இருக்காது, அது ஒரு செயல்முறையாக (procedure) மாறிவிடும்; எனவே அதை ஒரு skill-க்கு நகர்த்த வேண்டும்.

விதி கோப்புகள் எப்போது போதுமானவை

விதி கோப்புகள் பல இடங்களிலிருந்து ஏற்றப்படுகின்றன, பொதுவானவற்றிலிருந்து குறிப்பிட்டவை வரை: நிர்வகிக்கப்படும் கொள்கை கோப்பு, உங்கள் தனிப்பட்ட ~/.claude/CLAUDE.md, திட்டத்தின் ./CLAUDE.md அல்லது ./.claude/CLAUDE.md, மற்றும் gitignore செய்யப்பட்ட ./CLAUDE.local.md. கண்டறியப்பட்ட அனைத்து கோப்புகளும் ஒன்றையொன்று மேலெழுதாமல் (override) ஒன்றாக இணைக்கப்படுகின்றன, மேலும் உங்கள் பணி அடைவுக்கு (working directory) அருகில் உள்ள கோப்புகள் கடைசியாக வாசிக்கப்படுகின்றன.

v2.1.277 பதிப்பிலிருந்து, Claude Code AGENTS.md கோப்பையும் வாசிக்கிறது. ஆனால், உங்கள் பணி அடைவிலோ அல்லது அதற்கு மேலோ CLAUDE.md, .claude/CLAUDE.md அல்லது CLAUDE.local.md இல்லாதபோது மட்டுமே இது இயல்பாக நடக்கும். உங்கள் களஞ்சியத்தில் (repository) இரண்டுமே இருந்தால், Claude CLAUDE.md கோப்புகளை மட்டுமே வாசிக்கும். எனவே, காலப்போக்கில் முரண்படக்கூடிய இரண்டு பிரதிகளை பராமரிக்க வேண்டாம்.

ln -s AGENTS.md CLAUDE.md

symlink வெற்றிகரமாக அமைக்கப்பட்டால் எந்த வெளியீடும் வராது. ஒரு session-ஐத் தொடங்கி, /context all-ஐ இயக்கவும், பின்னர் Memory files பிரிவின் கீழ் CLAUDE.md தோன்றுகிறதா என்று உறுதிப்படுத்தவும். அது அங்கு பட்டியலிடப்படவில்லை என்றால், agent அதை இதுவரை கண்டறியவில்லை என்று அர்த்தம், சொற்களை மாற்றி அமைப்பதன் மூலம் இதை சரிசெய்ய முடியாது. உங்களுக்கு Claude-க்குரிய வரிகளும் தேவைப்பட்டால், import முறையைப் பயன்படுத்தி, அவற்றை import-க்கு கீழே சேர்க்கவும்.

@AGENTS.md

## Claude Code

Use plan mode for changes under `src/billing/`.

இதில் ஒரு சிக்கல் உள்ளது. @path import-கள் context-ஐச் சேமிப்பதில்லை. import செய்யப்பட்ட கோப்பு விரிவுபடுத்தப்பட்டு, அதை அழைக்கும் கோப்புடன் சேர்த்து தொடக்கத்திலேயே ஏற்றப்படும்; இது நான்கு நிலைகள் (hops) வரை செல்லும். 600 வரிகள் கொண்ட ஒரு விதி கோப்பை ஆறு import-களாகப் பிரிப்பது மனிதர்களுக்குப் புரிதலை எளிதாக்குமே தவிர, token செலவில் எந்த மாற்றத்தையும் ஏற்படுத்தாது. AGENTS.md மற்றும் அதன் மனித-வாசிப்பு வடிவத்திற்குப் பின்னால் உள்ள மரபுகள் குறித்த கட்டுரையை உங்கள் கோப்பு அமைப்பை முடிவு செய்வதற்கு முன் வாசிப்பது நல்லது.

செலவைக் குறைப்பது .claude/rules/ மற்றும் அதன் paths புலம் மட்டுமே. paths frontmatter கொண்ட ஒரு விதி கோப்பு, agent ஒரு குறிப்பிட்ட கோப்பைத் தொடும்போது மட்டுமே ஏற்றப்படும்.

---
paths:
  - "src/api/**/*.ts"
---

# API rules

- Every endpoint validates its input.
- Use the standard error response shape.

paths புலம் இல்லாத ஒரு விதி, .claude/CLAUDE.md-க்கு இணையான முன்னுரிமையுடன் தொடக்கத்திலேயே ஏற்றப்படும். எனவே, குறுகிய மற்றும் நிபந்தனையற்ற விதிகளைப் பயன்படுத்துவதே சிறந்த நடைமுறை; ஒரு குறிப்பிட்ட அடைவுக்குள் மட்டும் தேவைப்படும் விதிகளுக்கு paths பட்டியலைப் பயன்படுத்தவும்.

திறன் (skill) தேவைப்படும்போது

ஒரு திறன் என்பது அதனுள் SKILL.md கோப்பைக் கொண்ட ஒரு directory ஆகும். தனிப்பட்ட திறன்கள் ~/.claude/skills/<name>/SKILL.md-ல் சேமிக்கப்படுகின்றன, இவை உங்கள் கணினியில் உள்ள அனைத்து project-களுக்கும் பொருந்தும். Project சார்ந்த திறன்கள் .claude/skills/<name>/SKILL.md-ல் சேமிக்கப்படுகின்றன; இவை repository-உடன் இணைந்து பயணிக்கும், மேலும் மற்ற கோப்புகளைப் போலவே pull request மூலம் இவற்றை ஆய்வு செய்ய முடியும்.

mkdir -p ~/.claude/skills/summarize-changes
---
name: summarize-changes
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.
---

Run `git status` and `git diff` against the merge base.
Group the changes by intent, not by file.
Call out anything touching auth, migrations or deletions.

அந்தக் கோப்பின் description பகுதி மட்டுமே திறன் இயங்குவதற்கு முன்பு context-ல் இருக்கும், எனவே இது இரண்டு பணிகளைச் செய்கிறது. இது திறன் என்ன செய்கிறது என்பதையும், அதை எப்போது பயன்படுத்த வேண்டும் என்பதையும் குறிப்பிடுகிறது. "Helps with deploys" என்று ஒரு விளக்கம் இருந்தால், பயனர் கோரிக்கையை ஒப்பிட்டுப் பார்க்க அந்த model-க்கு எந்தத் தகவலும் கிடைக்காது. இதனால் அந்தத் திறன் இயங்காது, திறன்கள் வேலை செய்யவில்லை என்று நீங்கள் முடிவுக்கு வருவீர்கள்.

Directory-ன் பெயரே command-ஆக மாறும், எனவே மேலே உள்ள உதாரணம் உங்களுக்கு /summarize-changes-ஐத் தருகிறது. ஒரு தனிப்பட்ட அல்லது project திறனில், directory பெயரிலிருந்து மாறுபட்ட frontmatter name-ஐப் பயன்படுத்தினால், / menu-வில் அந்தப் பெயர் காட்டப்படும். அந்தப் பெயர் ஏற்கனவே வேறொரு command-க்கு பயன்பாட்டில் இல்லை என்றால் மட்டுமே இது நடக்கும்; directory பெயர் எப்போதும் அந்தத் திறனை இயக்கும்.

ஒரு திறன் இயக்கப்பட்டவுடன், அதன் rendered content ஒரு செய்தியாக உரையாடலில் நுழையும், அது அந்த session முழுவதும் அங்கேயே இருக்கும். Claude Code பிற்காலத் தருணங்களில் அந்தக் கோப்பை மீண்டும் வாசிப்பதில்லை. ஒருமுறை மட்டும் செய்யும் படிகளுக்குப் பதிலாக, நிரந்தரமான அறிவுறுத்தல்களை எழுதுங்கள். Body-ஐச் சுருக்கமாக வைத்திருங்கள், ஏனெனில் அந்த இடத்திலிருந்து ஒவ்வொரு வரியும் ஒவ்வொரு கோரிக்கையின் போதும் context-ல் இருக்கும். Auto-compaction-க்குப் பிறகு, Claude Code ஒவ்வொரு திறனின் மிகச் சமீபத்திய செயல்பாட்டை மீண்டும் இணைக்கும். ஒவ்வொன்றின் முதல் 5,000 tokens-ஐ, மொத்தம் 25,000 tokens வரம்பிற்குள் வைத்திருக்கும். ஒரே session-ல் பல பெரிய திறன்களை இயக்கினால், பழையவை நீக்கப்படும்; நீண்ட உரையாடலுக்குப் பிறகு ஒரு திறன் ஏன் வேலை செய்வதை நிறுத்தியது போலத் தெரிகிறது என்பதற்கு இதுவே காரணம். அதை மீண்டும் இயக்கினால் அது திரும்ப வரும். செயல்முறை சார்ந்த ஒரு திறன் இந்த வர்த்தகத்தை உறுதிப்படுத்துகிறது: the unlazy skill and its Depth Tree method, வேலையை முன்கூட்டியே முடித்துவிட்டதாகக் கூறும் முகவரைத் தவிர்க்க, gates மற்றும் plan கோப்பிற்காக context-ஐச் செலவிடுகிறது. ஒரே செயல்முறை ஒன்றுக்கும் மேற்பட்ட codebase-களுக்குப் பொருந்தும் போது, கோப்புகளை நகலெடுப்பதற்குப் பதிலாக share one skill across several repositories என்பதைப் பின்பற்றுங்கள்.

MCP server எப்போது தேவைப்படும்

ஒன்றைச் சேர்ப்பது ஒரு எளிய command மட்டுமே, அதன் போக்குவரத்து முறை (transport) அதன் வடிவத்தைத் தீர்மானிக்கிறது.

# Remote HTTP server
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Remote HTTP server behind a bearer token
claude mcp add --transport http secure-api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"

# Local stdio server: everything after -- is passed through untouched
claude mcp add --env AIRTABLE_API_KEY=YOUR_KEY --transport stdio airtable \
  -- npx -y airtable-mcp-server

-- முக்கியமானது. Stdio server-க்கு, இது Claude Code-ன் சொந்த விருப்பங்களையும் (options) உங்கள் server-ஐத் தொடங்கும் command line-ஐயும் பிரிக்கிறது. இதைத் தவிர்த்தால், server-க்காகக் கருதப்பட்ட ஒரு --port 8080, claude mcp add-க்கான விருப்பமாகப் புரிந்துகொள்ளப்படும், அதை அது நிராகரித்துவிடும்.

claude mcp list
claude mcp get notion

claude mcp add ஒரு Added ... வரியுடன் உறுதிப்படுத்துகிறது, இது configuration வட்டில் எழுதப்பட்டதை மட்டுமே தெரிவிக்கும். claude mcp list என்பது உண்மையைச் சொல்லும் command, ஏனெனில் இது ஒவ்வொரு server-க்கும் அருகில் அதன் ஆரோக்கிய நிலையை (health status) அச்சிடும்: ✔ Connected, ! Needs authentication, அல்லது ✘ Failed to connect. தோல்வி நிலை (failure status) என்பது Claude Code-ஆல் அந்த server-ஐ அணுக முடியவில்லை என்று பொருள், list command பழுதடைந்தது என்று பொருளல்ல. ஒரு session-க்குள், /mcp ஒவ்வொரு server-க்கும் அதே பார்வையை, tool எண்ணிக்கையுடன் வழங்குகிறது.

MCP server-க்கான ஒவ்வொரு அழைப்பும் தனித்துவமானது மற்றும் அதற்குத் தேவையானவற்றை அதுவே சுமந்து செல்கிறது, இதனால்தான் MCP server உங்கள் முந்தைய கோரிக்கையை நினைவில் கொள்வதில்லை. இது ஒரு வடிவமைப்புத் தேர்வு, இதன் விளைவை நீங்கள் ஏற்க வேண்டும்: சேமிக்க வேண்டிய எந்தவொரு நிலையும் (state) server-க்கு பின்னால், ஒரு database-ல் அல்லது கோப்பில் இருக்க வேண்டும், அதை இப்போது நீங்கள் நிர்வகிக்க வேண்டும்.

MCP server என்பது நீங்கள் இயக்க வேண்டிய ஒரு process

விற்பனையாளர்கள் ஒப்பிடும்போது தவிர்க்கும் செலவு இதுதான். ஒரு skill என்பது ஒரு கோப்பு (file). ஒரு MCP server என்பது எங்கோ ஓரிடத்தில் இயங்கும் மென்பொருள்; அந்த இடம் உங்கள் VPS (virtual private server) ஆக இருக்கும்போது, அதன் uptime-க்கு நீங்களே பொறுப்பு.

stdio server என்பது மலிவான வழி. session தொடங்கும் போது Claude Code அதை ஒரு child process-ஆக உருவாக்குகிறது, session முடியும் போது அது தானாகவே நின்றுவிடும். இதைக் கண்காணிக்கவோ அல்லது தனி அட்டவணையில் patch செய்யவோ தேவையில்லை. remote HTTP server என்பது நீண்ட காலம் இயங்கும் ஒரு service; இதற்கு எந்தவொரு நீண்டகால service-க்கும் தேவைப்படும் விஷயங்கள் தேவை, முதலில் ஒரு தனி user கணக்கு. கீழே உள்ள unit இயங்கும் mcp user-ஐ உருவாக்கி, அதற்கு server-ன் directory-ஐ வழங்கவும்:

sudo useradd --system --home-dir /srv/notes-mcp --shell /usr/sbin/nologin mcp
sudo chown -R mcp:mcp /srv/notes-mcp
[Unit]
Description=Notes MCP server
After=network-online.target
Wants=network-online.target

[Service]
User=mcp
WorkingDirectory=/srv/notes-mcp
ExecStart=/usr/bin/node /srv/notes-mcp/dist/server.js
Environment=PORT=8931
Restart=on-failure
RestartSec=5
NoNewPrivileges=true
PrivateTmp=true

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable --now notes-mcp
systemctl is-active notes-mcp
journalctl -u notes-mcp -n 50 --no-pager

systemctl is-active கட்டளை active என்று அச்சிட வேண்டும். அது failed என்று அச்சிட்டால், journal-ல் அதற்கான காரணம் இருக்கும். முதல்முறை இயக்கும்போது, பெரும்பாலும் விடுபட்ட environment variable அல்லது ஏற்கனவே வேறொரு process பயன்படுத்தும் port காரணமாகவே இது நிகழும். Restart=on-failure இங்கே கட்டாயமானது, ஏனெனில் ஒரு MCP server செயலிழந்தால் அது தானாகவே அறிவிக்காது. உங்கள் issue tracker-ஐ அணுக முடியவில்லை என்று agent சொல்லும்போதுதான் உங்களுக்குத் தெரியும்.

Process-ஐ 127.0.0.1-ல் bind செய்து, அதற்கு முன்னால் TLS (transport layer security) கொண்ட ஒரு reverse proxy-ஐ அமைக்கவும். உங்கள் database-ஐ அணுகும் ஒரு MCP server, எந்தவிதமான authentication-ம் இன்றி public port-ல் இயங்கினால், அது உங்கள் database-ஐ பொதுவெளியில் வெளியிட்டதற்குச் சமம். VPS-ல் MCP server-ஐ இயக்குதல் என்ற பகுதி proxy, certificate மற்றும் firewall அமைப்புகளை விரிவாக விளக்குகிறது.

பிறகு, தொடர்ச்சியாகச் செய்ய வேண்டிய வேலைகளைக் கணக்கிடுங்கள். இந்த service-க்கு அதனுடன் பேசும் agent-க்கும் தொடர்பில்லாத வகையில், தனி அட்டவணையில் security updates செய்ய வேண்டும். அதன் OAuth token காலாவதியாகும்போது, claude mcp list தகுதியற்ற நேரத்தில் ! Needs authentication என்று அச்சிடத் தொடங்கும். அதன் credentials ஒரு config file-லோ அல்லது Authorization header-லோ இருக்கும், எனவே மற்ற ரகசியங்களைப் போலவே இதையும் கவனமாகக் கையாள வேண்டும். இது ஒரு தனித் தலைப்பு: AI agent-ன் அணுகலுக்கு அப்பாற்பட்டு ரகசியங்களைப் பாதுகாத்தல். ஒரு skill-க்கு இந்த வேலைகள் எதுவுமே இல்லை.

நீங்கள் உருவாக்குவதற்கு முன்பு மாற்று வழிகளுடன் ஒப்பிட்டுப் பாருங்கள். முன்மொழியப்பட்ட server-ன் பின்னால் உள்ள தரவு காலாண்டுக்கு ஒருமுறைதான் மாறுகிறது என்றால், agent எங்கே பார்க்க வேண்டும் மற்றும் fields எதைக் குறிக்கின்றன என்று சொல்லும் ஒரு skill, நீங்கள் பராமரிக்க வேண்டிய service-ஐ விட மலிவானது.

உங்கள் context செலவை எவ்வாறு அளவிடுவது

தோராயமாக மதிப்பிடுவதை நிறுத்திவிட்டு, ஒரு session-க்குள் /context all கட்டளையை இயக்கவும். இது system prompt, memory files, tools, மற்றும் MCP servers ஆகியவற்றின் தற்போதைய விவரங்களையும், ஒவ்வொன்றின் token அளவையும் காட்டும்.

இரண்டு விஷயங்களைச் சரிபார்க்கவும். Memory files பிரிவின் கீழ், நீங்கள் எதிர்பார்க்கும் அனைத்து rules கோப்புகளும் பட்டியலிடப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும். ஒரு கோப்பு விடுபட்டிருந்தால், அது agent-க்குத் தெரியாது. எனவே, உங்கள் அறிவுறுத்தல்கள் புறக்கணிக்கப்படும்போது முதலில் இதைக் கவனிக்க வேண்டும். கோப்பு பட்டியலிடப்பட்டிருந்தும் விதி புறக்கணிக்கப்பட்டால், அதற்கான காரணம் வேறெங்கோ உள்ளது. ஒரு agent தனக்குத் தெரிந்த அறிவுறுத்தலைப் புறக்கணிப்பதற்கான காரணங்கள் என்பதை மீண்டும் எழுதுவதற்கு முன்பு ஆராய்வது நல்லது. அடுத்து, உங்கள் servers-ன் செலவைப் பார்க்கவும். மாதத்திற்கு இருமுறை மட்டுமே பயன்படுத்தும் ஒரு server, அந்தப் பட்டியலில் அதிக செலவை ஏற்படுத்தும் ஒன்றாக இருந்தால், அதை /mcp-ல் அணைத்துவிட்டு, தேவைப்படும் session-களுக்கு மட்டும் மீண்டும் இயக்கவும். configuration அப்படியே சேமிக்கப்படும்.

உங்கள் கணக்கிற்கு discovery cache இயக்கப்பட்டிருந்தால், நீங்கள் முன்பு பயன்படுத்திய ஒரு remote server cached 2h ago · connects on first use · 5 tools போன்ற நிலையைக்காட்டலாம். அதாவது, Claude Code தொடக்கத்திலேயே இணைக்காமல், முந்தைய session-லிருந்து tool பட்டியலைப் படித்துள்ளது என்று பொருள். ஒரு tool முதன்முதலில் அழைக்கப்படும்போது அது இணைப்பை ஏற்படுத்தும். முதல் செய்தியிலிருந்தே கருவிகள் பயன்பாட்டிற்குத் தயாராக இருப்பதால், இதில் சரிசெய்ய எதுவும் இல்லை. படிப்படியான வெளியீட்டின் மூலம் உங்களுக்கு இயக்கப்பட்டிருந்தால் தவிர, cache இயல்பாகவே அணைக்கப்பட்டிருக்கும்: ஒவ்வொரு server-ம் தொடக்கத்திலேயே இணைக்கப்படுவதை உறுதி செய்ய MCP_DISCOVERY_CACHE=0-ஐ அமைக்கவும், அல்லது cache-ஐ இயக்க 1-ஐப் பயன்படுத்தவும். கூடுதல் விவரங்களுக்கு, Claude Code context window-ஐ நிர்வகித்தல் என்பது compaction-க்குப் பிறகும் எவை எஞ்சியிருக்கும் என்பதை விளக்குகிறது, மேலும் அந்த tokens-ன் உண்மையான செலவு என்பது அந்த எண்களைப் பணமாக மாற்றிக் காட்டுகிறது.

எனது skill ஏன் ஒருபோதும் தூண்டப்படுவதில்லை?

இதற்கான பொதுவான காரணம் description ஆகும். ஒரு skill இயங்குவதற்கு முன்னால் சூழலில் இருக்கும் ஒரே உரை இதுதான், எனவே இது அந்தச் சூழலை சரியாகக் குறிப்பிடவில்லை என்றால், எதுவும் பொருந்தாது. தூண்டுதலை (trigger) வாக்கியத்தில் இவ்வாறு எழுதவும்: "பயனர் என்ன மாற்றப்பட்டது என்று கேட்கும்போதோ, commit message தேவைப்படும்போதோ அல்லது diff-ஐ ஆய்வு செய்யக் கேட்கும்போதோ இதைப் பயன்படுத்தவும்." தெளிவற்ற விளக்கங்கள் எந்த அறிவிப்பும் இன்றி தோல்வியடையும், இதனால் இதைக் கண்டறிவது கடினம்.

இரண்டாவது காரணம் frontmatter-ல் ஏற்படும் எழுத்துப் பிழை, Claude Code-ல் இதுவும் எந்த அறிவிப்பும் இன்றி நடக்கும். ஒரு field-ன் பெயர், அதில் உள்ள hyphen-கள் உட்பட, சரியாகப் பொருந்த வேண்டும். அங்கீகரிக்கப்படாத field-ஐ Claude Code எந்தப் பிழையும் காட்டாமல் புறக்கணித்துவிடும். நீங்கள் skill-ஐ package செய்யும்போது அல்லது claude.ai அல்லது Skills API-க்கு பதிவேற்றும்போது மட்டுமே இது குறித்த எச்சரிக்கை வரும், ஏனெனில் அவை குறிப்பிட்ட சில field-களை மட்டுமே ஏற்கும், மற்றவற்றை நிராகரித்துவிடும்:

Unexpected key(s) in SKILL.md frontmatter: argument-hint. Allowed properties are: allowed-tools, compatibility, description, license, metadata, name

மூன்றாவது காரணம் இருப்பிடம். Project skills-கள் உங்கள் working directory-யிலும், repository root வரை உள்ள ஒவ்வொரு parent directory-யிலும் உள்ள .claude/skills/-லிருந்து ஏற்றப்படுகின்றன. நீங்கள் தொடங்கிய இடத்திற்கு கீழே உள்ள nested directory-களில் இருக்கும் skills-கள் தொடக்கத்தின்போது ஏற்றப்படாது. அந்த subdirectory-க்குள் இருக்கும் ஒரு கோப்பை agent படிக்கும்போது அல்லது திருத்தும்போது மட்டுமே அவை தோன்றும், அதுவரை அவை autocomplete-ல் வராது மற்றும் பெயரைக் கொண்டு அழைக்கவும் முடியாது.

இந்த அமைதியான தோல்விக்கு இணையான MCP சிக்கல், url-ஐக் கொண்டு, type இல்லாமல் இருக்கும் ஒரு .mcp.json உள்ளீடு ஆகும். type இல்லாத எந்தவொரு உள்ளீட்டையும் Claude Code ஒரு stdio server-ஆகக் கருதுகிறது, எனவே அது அந்த உள்ளீட்டைத் தவிர்த்துவிட்டு, பின்வருமாறு தெரிவிக்கும்:

MCP server "notes" has a "url" but no "type"; add "type": "http" (or "sse" / "ws") to this entry

மூன்றையும் ஒன்றாகப் பயன்படுத்துதல்

இந்த வழிமுறைகள் ஒரே தேவைக்காகப் போட்டியிடுவதில்லை. ஒவ்வொன்றையும் அதன் பயன்பாடு எளிதான இடத்தில் பயன்படுத்துவதே சரியான அமைப்பாகும். Rules file-ல் எல்லா இடங்களுக்கும் பொருந்தக்கூடிய சில வரிகள் மட்டுமே இருக்கும். Skills என்பது நடைமுறைகளைக் கொண்டிருக்கும், அவை தேவைப்படும்போது மட்டுமே load ஆகும். உள்ளடக்கத்தை முன்கூட்டியே கணிக்க முடியாத அமைப்புகளை இணைக்க, ஒன்று அல்லது இரண்டு MCP server-கள் பயன்படுத்தப்படுகின்றன. இவற்றில் முதலாவதைப் பற்றிய உங்கள் புரிதலை மேம்படுத்த, agent skill என்பது உண்மையில் என்ன என்ற பகுதி அதன் வடிவத்தை விரிவாக விளக்குகிறது.

ஒரு விஷயம் எங்கே இருக்க வேண்டும் என்ற விவாதத்தைத் தீர்க்க ஒரு சோதனை உதவும். அதை நீக்கிவிட்டு, புதிய session-ஐத் தொடங்கி, அந்தப் பணியை agent-க்குக் கொடுங்கள். agent மெதுவாகச் செயல்பட்டால், அது ஒரு skill-ல் இருந்திருக்க வேண்டும். agent தவறான தகவலை உறுதியாகக் கூறினால், அது rules file-ல் இருந்திருக்க வேண்டும். agent-ஆல் அந்தத் தகவலைப் பெறவே முடியவில்லை என்றால், உங்களுக்கு server தேவைப்படுகிறது, மேலும் அந்த server-ஐத் தொடர்ந்து இயங்க வைப்பதற்கான திட்டமும் தேவை.

FAQ

நான் ஒரு skill-ஐ எழுத வேண்டுமா அல்லது MCP server-ஐ உருவாக்க வேண்டுமா?

ஒவ்வொரு முறை இயக்கும்போதும் தகவல் மாறுகிறதா என்பதைப் பொறுத்து முடிவெடுங்கள். issue tracker, database அல்லது dashboard போன்ற, மற்றவர்கள் மாற்றக்கூடிய நேரடித் தகவல்களை agent படிக்க வேண்டியிருந்தால், உங்களுக்கு MCP server தேவை. ஏனெனில், நீங்கள் எழுதும் தகவல் பதிவு மாறியவுடன் காலாவதியாகிவிடும். ஒரு பதிலை ஒருமுறை எழுதி வைத்துவிட்டு, ஆறு வாரங்கள் கழித்தும் அது சரியாக இருக்கும் என்றால், ஒரு skill-ஐ எழுதுங்கள். Skill என்பது git-ல் உள்ள ஒரு கோப்பு; இதற்குத் தனிச் செயல்முறை (process) தேவையில்லை, port-ஐத் திறக்க வேண்டியதில்லை, patch schedule-ம் கிடையாது. எனவே, சாத்தியமான இடங்களில் இதுவே செலவு குறைந்த வழி.

MCP server-கள் இன்னும் எனது context window-வை நிரப்புகின்றனவா?

முன்பை விட மிகக் குறைவாகவே நிரப்புகின்றன. தற்போதைய Claude Code-ல் tool search இயல்பாகவே (default) செயல்படுத்தப்பட்டுள்ளது. எனவே, session தொடங்கும் போது tool-ன் பெயர்களும் server-ன் instructions பகுதி மட்டுமே ஏற்றப்படும். Claude தேடும்போது மட்டுமே முழுமையான schemas பெறப்படும். v2.1.304 முதல், ANTHROPIC_BASE_URL மூலம் அமைக்கப்பட்ட LLM gateway-க்கு பின்னால் உள்ள sessions-க்கும் இது பொருந்தும். ENABLE_TOOL_SEARCH=false மூலம் அமைக்கப்பட்ட server-க்கு, "alwaysLoad": true-ல் உள்ளவாறு, Claude Opus 4 மற்றும் Sonnet 4-க்கு முந்தைய மாடல்களில் (Google Cloud-ன் Agent Platform-ல் 4.5 தலைமுறைக்கு முந்தையவை), மற்றும் Azure-ல் உள்ள Microsoft Foundry deployments-ல் மட்டுமே முன்கூட்டியே ஏற்றுதல் (upfront loading) நடக்கும். நீங்கள் எந்த நிலையில் இருக்கிறீர்கள் என்பதை அறிய /context all-ஐ இயக்கவும், ஏனெனில் பழைய ஒப்பீட்டுப் பதிவுகளில் உள்ள எண்கள் முன்கூட்டியே ஏற்றுதலை அடிப்படையாகக் கொண்டவை.

Claude Code AGENTS.md-ஐப் படிக்கிறதா?

ஆம், v2.1.277 முதல் படிக்கிறது. ஆனால், உங்கள் working directory-யிலோ அல்லது அதற்கு மேலோ CLAUDE.md, .claude/CLAUDE.md அல்லது CLAUDE.local.md இல்லாதபோது மட்டுமே இது இயல்பாக நடக்கும். உங்கள் repository-ல் இவை இரண்டும் இருந்தால், Claude CLAUDE.md கோப்புகளை மட்டுமே படிக்கும். எனவே, இரண்டு பிரதிகளை வைத்திருப்பதற்குப் பதிலாக, ஒன்றை மற்றொன்றைச் சுட்டிக்காட்டும்படி செய்யுங்கள். சாதாரண symlink-க்கு ln -s AGENTS.md CLAUDE.md-ஐ இயக்கவும், அல்லது CLAUDE.md-ன் முதல் வரியில் @AGENTS.md-ஐச் சேர்த்து, அதற்கு கீழே Claude-க்கான அறிவுறுத்தல்களைச் சேர்க்கவும். பிறகு ஒரு session-ஐத் தொடங்கி, CLAUDE.md என்பது Memory files-ன் கீழ் வருகிறதா என்பதை உறுதிப்படுத்த /context all-ஐ இயக்கவும்.

ஒரு session-ன் பாதியில் எனது skill ஏன் செயல்படாமல் போனது?

இதற்கு வழக்கமான காரணம் auto-compaction ஆகும். உரையாடல் சுருக்கப்படும்போது (summarized), Claude Code ஒவ்வொரு skill-ன் மிக அண்மைய செயல்பாட்டையும் மீண்டும் இணைக்கும். ஒவ்வொன்றிலும் முதல் 5,000 tokens-ஐ வைத்துக்கொண்டு, அனைத்திற்கும் சேர்த்து மொத்தம் 25,000 tokens என்ற வரம்பிற்குள் வைத்திருக்கும். கடைசியாக இயக்கப்பட்ட skill-லிருந்து இந்த வரம்பு நிரப்பப்படும். எனவே, நீங்கள் பல பெரிய skill-களை இயக்கியிருந்தால், பழையவை முழுமையாக நீக்கப்படும். அதன் முழு உள்ளடக்கத்தையும் மீட்டெடுக்க, அந்த skill-ஐ மீண்டும் இயக்கவும்.

நீண்ட rules கோப்பு ஒவ்வொரு session-லும் ஏற்றப்படுவதை எப்படித் தடுப்பது?

எப்போதாவது மட்டுமே தேவைப்படும் பகுதிகளை paths field கொண்ட .claude/rules/ கோப்புகளாக மாற்றவும். அப்போதுதான், agent அதற்குப் பொருத்தமான கோப்பைத் தொடும்போது மட்டும் அவை ஏற்றப்படும். கோப்பை @path imports-ஆகப் பிரிப்பது உதவாது, ஏனெனில் import செய்யப்பட்ட கோப்புகள், அவற்றை அழைக்கும் கோப்புடன் சேர்த்துத் தொடக்கத்திலேயே விரிவுபடுத்தப்பட்டு ஏற்றப்படும். நிலையான உண்மையாக இல்லாமல், பல படிகளைக் கொண்ட செயல்முறையாக இருந்தால், அதை ஒரு skill-ஆக மாற்றுவதே சிறந்தது. ஏனெனில், ஒரு skill-ன் உள்ளடக்கம் இயக்கப்படும் வரை எந்தச் செலவும் (cost) இல்லை.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?