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

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) ஏற்படுத்துகிறது என்பதே சரியான கேள்வி.

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

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

ஒரு rules கோப்பு ஒவ்வொரு அமர்விலும் (session), அது தேவைப்பட்டாலும் இல்லாவிட்டாலும், தொடக்கத்திலேயே முழுமையாக ஏற்றப்படும். Claude Code ஒவ்வொரு உரையாடலின் தொடக்கத்திலும் CLAUDE.md-ஐ வாசித்து, அதன் நீளத்தைப் பொருட்படுத்தாமல் முழுமையாக ஏற்றுகிறது. ஆவணப்படுத்தப்பட்ட இலக்கு ஒரு கோப்பிற்கு 200 வரிகளுக்குக் குறைவாக இருக்க வேண்டும் என்பதாகும், ஏனெனில் நீண்ட கோப்பு அதிக context-ஐ செலவழிப்பதுடன், சரியாகப் பின்பற்றப்படுவதையும் குறைக்கிறது. இந்த இரண்டு விளைவுகளும் ஒரே திசையில் செயல்படுவதால், 900 வரிகள் கொண்ட rules கோப்பு பயனற்றதை விட மோசமானது.

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

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

[
  {
    "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 வரிகள் கொண்ட ஒரு rules கோப்பு சுமார் 10 KB markdown ஆகும், ஒரு skill விளக்கம் சுமார் 160 எழுத்துக்கள், மற்றும் பன்னிரண்டு tools-ஐ வழங்கும் ஒரு server சுமார் 18 KB schema மற்றும் 2 KB instructions தொகுதியைக் கொண்டுள்ளது. Claude Code ஒவ்வொரு tool விளக்கத்தையும் மற்றும் ஒவ்வொரு server instructions பகுதியையும் 2 KB-ல் வெட்டிவிடுகிறது (truncate), எனவே அந்தப் பகுதிக்கு ஒரு உச்சவரம்பு உள்ளது. உங்கள் சொந்த உண்மையான எண்களை எவ்வாறு பார்ப்பது என்பதை அடுத்த பகுதி விளக்குகிறது.

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

Tool search-க்கு tool_reference தொகுதிகளை ஆதரிக்கும் ஒரு model தேவைப்படுகிறது; ஆகஸ்ட் 2026 நிலவரப்படி, இது Claude Sonnet 4.5, Haiku 4.5, Opus 4.5 மற்றும் அதற்குப் பிந்தைய பதிப்புகளைக் குறிக்கிறது. ANTHROPIC_BASE_URL முதல் தரப்பு (first party) அல்லாத ஒரு host-ஐக் குறிக்கும்போது Claude Code இதை ஆஃப் செய்கிறது, ஏனெனில் பெரும்பாலான proxies அந்தத் தொகுதிகளை forward செய்வதில்லை. இதைக் கட்டுப்படுத்த ENABLE_TOOL_SEARCH-ஐ அமைக்கவும்: false அனைத்து schema-க்களையும் தொடக்கத்திலேயே ஏற்றுகிறது, true அனைத்தையும் தள்ளிவைக்கிறது, மற்றும் auto அவை context window-ன் 10%-க்குள் பொருந்தும்போது மட்டுமே தொடக்கத்திலேயே ஏற்றுகிறது.

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

ஆறு வாரங்கள் கழித்து யாரும் பராமரிக்காவிட்டாலும் அந்தப் பதில் சரியாகவே இருக்கும் என்றால், உங்களுக்கு ஒரு 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/. ஒவ்வொன்றும் ஒரு வரி. ஒரு பதிவு படிநிலைகளாக (steps) வளரும் தருணத்தில், அது உண்மையாக இருப்பதிலிருந்து மாறி ஒரு நடைமுறையாக (procedure) ஆகிவிடுகிறது; எனவே அதை ஒரு skill-க்கு நகர்த்த வேண்டும்.

எப்போது ஒரு rules கோப்பு போதுமானது

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

Claude Code CLAUDE.md-ஐ வாசிக்கிறது, AGENTS.md-ஐ அல்ல. பிற கருவிகளுக்காக உங்கள் repository-ல் ஏற்கனவே AGENTS.md இருந்தால், அவை காலப்போக்கில் மாறுபடும் என்பதால் இரண்டு பிரதிகளை பராமரிக்க வேண்டாம்.

ln -s AGENTS.md CLAUDE.md

வெற்றிகரமாக அமைந்தால், symlink எதையும் அச்சிடாது. ஒரு session-ஐத் தொடங்கி, /context-ஐ இயக்கவும், பின்னர் 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 வரிகள் கொண்ட ஒரு rules கோப்பை ஆறு import-களாகப் பிரிப்பது மனிதர்களுக்குப் புரிதலை எளிதாக்கும், ஆனால் token செலவில் எந்த மாற்றத்தையும் ஏற்படுத்தாது. AGENTS.md மற்றும் அதன் மனிதர்களுக்குரிய இணையான கோப்பிற்குப் பின்னால் உள்ள மரபுகள் குறித்த கட்டுரையை ஒரு அமைப்பை முடிவு செய்வதற்கு முன் வாசிப்பது நல்லது.

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

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

# API rules

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

paths புலம் இல்லாத ஒரு rule, தொடக்கத்திலேயே .claude/CLAUDE.md-க்கு இணையான முன்னுரிமையுடன் ஏற்றப்படும். எனவே, குறுகிய நிபந்தனையற்ற விதிகள் (unconditional rules) மற்றும் ஒரு குறிப்பிட்ட directory-க்குள் மட்டுமே தேவைப்படும் எதற்கும் 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 திறனில், frontmatter name என்பது பட்டியல்களில் காட்டப்படும் label-ஐ மட்டுமே அமைக்கும்.

ஒரு திறன் அழைக்கப்பட்டவுடன், அதன் rendered உள்ளடக்கம் ஒரு செய்தியாக உரையாடலில் நுழையும், மேலும் அந்த session முழுவதும் அங்கேயே இருக்கும். Claude Code அடுத்தடுத்த சுற்றுகளில் அந்தக் கோப்பை மீண்டும் படிப்பதில்லை. ஒருமுறை மட்டும் செய்யும் படிகளுக்குப் பதிலாக, நிரந்தரமான அறிவுறுத்தல்களை எழுதுங்கள். அதன் உள்ளடக்கத்தைச் சுருக்கமாக வைத்திருங்கள், ஏனெனில் அந்தப் புள்ளியிலிருந்து ஒவ்வொரு வரியும் ஒவ்வொரு கோரிக்கையின் போதும் கூடுதல் செலவாக (token cost) அமையும். Auto-compaction-க்கு பிறகு, Claude Code ஒவ்வொரு திறனின் மிக சமீபத்திய அழைப்பை மீண்டும் இணைக்கும். ஒவ்வொன்றின் முதல் 5,000 tokens-ஐ, 25,000 tokens என்ற மொத்த வரம்பிற்குள் வைத்திருக்கும். ஒரே session-ல் பல பெரிய திறன்களை அழைத்தால், பழையவை முழுமையாக நீக்கப்படும்; நீண்ட உரையாடலுக்குப் பிறகு ஒரு திறன் வேலை செய்யாதது போலத் தோன்றுவதற்கு இதுவே காரணம். அதை மீண்டும் அழைத்தால் அது திரும்ப வரும். ஒரே செயல்முறை ஒன்றுக்கும் மேற்பட்ட codebase-களுக்குப் பொருந்தும் போது, கோப்புகளை நகலெடுப்பதற்குப் பதிலாக ஒரு திறனை பல repository-களில் பகிருங்கள்.

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

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

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

[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 விடுபட்டிருக்கலாம் அல்லது அந்த port ஏற்கனவே வேறொரு process-ஆல் பயன்படுத்தப்பட்டிருக்கலாம். 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-க்கும் அதற்கும் தொடர்பில்லாமல், service-க்குத் தனியாக 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 கட்டளையை இயக்கவும். இது startup விவரங்களை அச்சிடும்: system prompt, memory files, tools, மற்றும் MCP servers ஆகியவற்றின் token எடை உட்பட.

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

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

எனது skill ஏன் ஒருபோதும் செயல்படுவதில்லை?

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

இரண்டாவது காரணம் frontmatter-ல் ஏற்படும் பிழை, இது வெளிப்படையாகத் தெரியும். அறியப்படாத key நிராகரிக்கப்படும்:

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

மூன்றாவது காரணம் இருப்பிடம். Project skills, உங்கள் working directory-ல் உள்ள .claude/skills/ மற்றும் repository root வரை உள்ள அனைத்து parent directory-களிலிருந்தும் ஏற்றப்படும். நீங்கள் தொடங்கிய இடத்திற்கு கீழே உள்ள 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 ஒரு tool-ஐத் தேடும்போது மட்டுமே அதன் முழுமையான schemas பெறப்படும். Tool search முடக்கப்பட்டிருக்கும்போது, அல்லது ENABLE_TOOL_SEARCH=false-ஐப் பயன்படுத்தும்போதோ, அல்லது ANTHROPIC_BASE_URL-ஐ முதல் தரப்பு (first party) அல்லாத proxy-க்குக் குறிப்பிடும்போதோ, அல்லது Claude 4.5 தலைமுறைக்கு முந்தைய model-களைப் பயன்படுத்தும்போதோ, முழுமையாக முன்கூட்டியே ஏற்றும் (upfront loading) முறை நடக்கும். நீங்கள் எந்த நிலையில் இருக்கிறீர்கள் என்பதை அறிய /context-ஐ இயக்கவும். பழைய ஒப்பீட்டுப் பதிவுகளில் உள்ள எண்கள், முன்கூட்டியே ஏற்றும் முறையை அடிப்படையாகக் கொண்டவை.

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

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

ஒரு 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 பயன்படுத்தப்படும் வரை அதன் உள்ளடக்கம் எந்த இடத்தையும் எடுத்துக்கொள்ளாது.