Agent skills, MCP servers, rules files: ఏది ఎప్పుడు?
Coding agent కు context ఇవ్వడానికి skill, MCP server, rules file మధ్య తేడాలు తెలుసుకోండి. tokens, ప్రతి turn ఖర్చు, upkeep ఆధారంగా సరైనదాన్ని ఎంచుకోండి.
Agent skills, MCP servers, rules files మధ్య తేడా: సంక్షిప్త సమాధానం
Agent skills, MCP servers, rules files — ఇవన్నీ coding agent కు అవసరమైన జ్ఞానాన్ని అందిస్తాయి. ఆ జ్ఞానం ఏ పని చేస్తుందో ఆధారంగా ఎంపిక చేయండి. MCP (model context protocol) అనేది మీరు తదుపరిసారి పరిశీలించినప్పుడు మారి ఉండగల data కోసం ఉపయోగించాలి. Skill అనేది ఈరోజు రాసి ఉంచినా ఆరు వారాల తర్వాత కూడా సరైనదిగా ఉండే procedure కోసం ఉపయోగించాలి. ప్రతి session లోనూ తప్పనిసరిగా వర్తించాల్సిన కొన్ని facts కోసం rules file ఉపయోగించాలి.
ఈ ఎంపికకు ఒక ఖర్చు ఉంది. ఆ ఖర్చు context. Agent కు అవసరం లేని instruction పై ఖర్చు చేసే ప్రతి token, అది చదువుతున్న code కోసం అందుబాటులో ఉండదు. ప్రతి turn లోనూ దానికి మళ్లీ చెల్లించాలి, ఎందుకంటే ప్రతి request తో మొత్తం context window మళ్లీ పంపబడుతుంది. అందువల్ల ఉపయోగకరమైన ప్రశ్న “ఏ mechanism ఈ పని చేయగలదు?” అనేది కాదు. సాధారణంగా ఈ మూడింటితోనూ పని చేయవచ్చు. పనిలేకుండా ఉన్న సమయంలో ఏది తక్కువ ఖర్చు అవుతుందనేదే అసలు ప్రశ్న.
మీరు ఉపయోగించే ముందు ప్రతి ఎంపికకు అయ్యే ఖర్చు
ఈ మూడు వేర్వేరు సమయాల్లో లోడ్ అవుతాయి. ఆ సమయమే వాటి మధ్య ఉన్న ప్రధాన తేడా.
షరతుల్లేని rules file ప్రారంభ సమయంలో, ప్రతి sessionలో, అది సంబంధితమైనదైనా కాకపోయినా, మినహాయించనంతవరకు లోడ్ అవుతుంది. Claude Code ప్రతి conversation ప్రారంభంలో startup CLAUDE.md files ను చదువుతుంది. Code blocks వెలుపల ఉన్న block-level HTML comments ను content inject చేయడానికి ముందు తొలగిస్తుంది. 4 MiB కంటే పెద్ద files ను దాటవేస్తుంది. claudeMdExcludes ద్వారా managed policy file మినహా ఇతర files ను కూడా మినహాయించవచ్చు. ప్రతి file 200 lines కంటే తక్కువగా ఉండాలని documentation సూచిస్తుంది. కారణం, పొడవైన file ఎక్కువ context వినియోగిస్తుంది. అలాగే దానిని model తక్కువ విశ్వసనీయంగా అనుసరిస్తుంది. ఈ రెండు ప్రభావాలు ఒకే దిశలో పనిచేస్తాయి. అందుకే 900-line rules file ఉపయోగం లేకపోవడమే కాకుండా ప్రతికూలంగా ఉంటుంది.
ఒక skill రెండు దశల్లో లోడ్ అవుతుంది. ప్రారంభంలో ప్రతి SKILL.md frontmatter నుంచి description line మాత్రమే contextలోకి వస్తుంది. అందువల్ల skill అందుబాటులో ఉందని, అది సాధారణంగా ఎప్పుడు వర్తిస్తుందో modelకు తెలుస్తుంది. Skill invoke చేసినప్పుడు దాని body లోడ్ అవుతుంది. కాబట్టి 400-line reference document అవసరమైన క్షణం వరకు దాదాపు ఎలాంటి ఖర్చూ ఉండదు.
గతంలో MCP server ఎక్కువ ఖర్చయ్యే ఎంపిక. ఇప్పుడు మీరు చదివే చాలా comparisons పాతవిగా ఉండటానికి ఇదే కారణం. ప్రస్తుత Claude Codeలో tool search డిఫాల్ట్గా onలో ఉంటుంది. Session ప్రారంభంలో tool names మరియు server యొక్క instructions field మాత్రమే లోడ్ అవుతాయి. Claude వాటి కోసం search చేసినప్పుడు పూర్తి JSON (JavaScript object notation) schemas లోడ్ అవుతాయి. అందువల్ల serverను జోడించడం వల్ల ప్రారంభంలో ఇక వేల tokens ఖర్చు కావు. అయినప్పటికీ కొంత ఖర్చు ఉంటుంది. Tool search offగా ఉన్న 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"
}
]ఇవి estimates మాత్రమే. మీ machine నుంచి తీసిన measurements కావు. ప్రతి mechanism లోడ్ చేసే text పరిమాణం ఆధారంగా, సుమారు నాలుగు charactersకు ఒక token చొప్పున ఇవి లెక్కించబడ్డాయి. 200-line rules file సుమారు 10 KB markdown ఉంటుంది. Skill description సుమారు 160 characters ఉంటుంది. పన్నెండు toolsను అందించే serverలో సుమారు 18 KB schema మరియు 2 KB instructions block ఉంటాయి. Claude Code server instructions fieldను, అలాగే ప్రారంభంలో లోడ్ అయ్యే ప్రతి tool descriptionను, డిఫాల్ట్గా 4,096 charactersకు పరిమితం చేస్తుంది. Tool search ద్వారా లోడ్ అయ్యే tool descriptionకు పరిమితి 16,384 characters. v2.1.296కు ముందు చిన్న పరిమితి 2,048 charactersగా ఉండేది. మీరు CLAUDE_CODE_MAX_MCP_DESCRIPTION_LENGTH set చేస్తే అది రెండు పరిమితులనూ భర్తీ చేస్తుంది. అయితే కొన్ని Anthropic-hosted MCP servers నుంచి వచ్చే instructions మరియు descriptions CLAUDE_CODE_MAX_MCP_DESCRIPTION_LENGTH set చేసినా పూర్తి రూపంలో Claudeకు చేరుతాయి. అందువల్ల ఈ పరిమితులు సార్వత్రిక గరిష్ఠ పరిమితి కావు. మీ స్వంత వాస్తవ సంఖ్యలను ఎలా చదవాలో తదుపరి sectionలో చూపిస్తాను.
మొదటి రెండు rowsను కలిపి చూడండి. దాన్ని ఎవరూ అవసరం చేసుకోని sessionలో rules file 2,500 tokens ఖర్చు చేస్తుంది. అదే sessionలో skill 40 tokens ఖర్చు చేస్తుంది. అది పనిచేసే పది sessionsలో ఒక sessionలో ఈ ఖర్చు 3,000 tokens అవుతుంది. చివరి రెండు rows ఒకే serverకు సంబంధించినవి. మొదటిది tool search onలో ఉన్నప్పుడు, రెండవది offలో ఉన్నప్పుడు: 500 tokensతో పోలిస్తే 4,500. పాత MCP context bloat సలహా ఇప్పటికీ ప్రచారంలో ఉండటానికి ఈ తేడానే కారణం.
October 2026 నాటికి Claude Code, Claude Opus 4, Sonnet 4, Haiku 4.5 మరియు తరువాతి modelsలో tool searchను ఉపయోగిస్తుంది. Google Cloud's Agent Platformపై నడిచే Opus 4.5, Sonnet 4.5, Haiku 4.5 మరియు తరువాతి modelsలో కూడా ఇది ఉపయోగించబడుతుంది. పాత modelsలో, అలాగే Azureపై hosted Microsoft Foundry deploymentsలో, మీరు ఏ setting ఉంచినా ప్రతి MCP tool ప్రారంభంలోనే లోడ్ అవుతుంది. ANTHROPIC_BASE_URL ను LLM gatewayకు point చేసినప్పుడు, v2.1.304 నుంచి tool search డిఫాల్ట్గా onలో ఉంటుంది. Opt in చేయకపోతే పాత versionsలో అక్కడ ఇది offగా ఉండేది. v2.1.305 నుంచి, 400 లేదా 422 వచ్చిన తర్వాత Claude Code tool search లేకుండా gateway requestను మళ్లీ ప్రయత్నించగలదు. ఆ retry విజయవంతమైతే tools ప్రారంభంలోనే లోడ్ అవుతాయి. దీన్ని నియంత్రించడానికి ENABLE_TOOL_SEARCH set చేయండి: false ప్రతి schemaను ప్రారంభంలోనే లోడ్ చేస్తుంది. true schemasను defer చేస్తుంది; ఇది setting unsetగా ఉంచినప్పుడు ఉపయోగించే model మరియు deployment fallbacksనే ఉపయోగిస్తుంది. auto definitions మొత్తం context windowలో 10% కంటే తక్కువగా ఉన్నంతవరకు toolsను ప్రారంభంలో లోడ్ చేస్తుంది. ఆ threshold చేరిన తర్వాత total మళ్లీ దాని కంటే తక్కువకు పడిపోయినా tool searchను కొనసాగిస్తుంది. "alwaysLoad": true తో configure చేసిన server, ENABLE_TOOL_SEARCH విలువ ఏదైనా, తన toolsను ప్రారంభంలోనే లోడ్ చేస్తుంది.
# Load schemas up front only if they fit in 5% of the window
ENABLE_TOOL_SEARCH=auto:5 claudeనిర్ణయాత్మక ప్రశ్న: ప్రతి invocation మధ్య data మారుతుందా?
ముందుగా ఇదే ప్రశ్న అడగండి. దీనివల్ల ఒక ఎంపికను వెంటనే తొలగించవచ్చు. Agent తదుపరి సారి పరిశీలించినప్పుడు మారి ఉండగలిగే ఏదైనా data ను చదవాలి లేదా రాయాలి అంటే, మీకు server అవసరం. Issue tracker, database, monitoring dashboard లేదా మీ స్వంత internal API (application programming interface) ఇందుకు ఉదాహరణలు. దాన్ని file లో రాయడం వల్ల ప్రయోజనం ఉండదు. మరొకరు record ను edit చేసిన క్షణం, మీరు రాసిన సమాచారం పాతదైపోతుంది. మీ స్వంత codebase కూడా ఈ జాబితాలోకి వస్తుంది. ప్రతి commit తో దాని structure మారుతుంది. అందుకే layout ను కాలక్రమేణా పాతబడే file లో వివరించడం కంటే, MCP ద్వారా repository యొక్క parsed map ను agent కు అందించడం సరైన విధానం.
ఎవరూ నిర్వహించకపోయినా ఆ సమాధానం ఆరు వారాల తరువాత కూడా సరైనదిగానే ఉంటే, మీకు skill అవసరం. Release checklist. Migration procedure. మీ error responses యొక్క ఆకృతి. ఈ repository లో tests ఎలా రాయాలో తెలిపే విధానం. Skill అనేది git లోని file. దానికి port లేదా process ఉండదు. అది తప్పుగా ఉండటమే దాని ఏకైక failure mode. Code review ద్వారా దాన్ని గుర్తించవచ్చు.
మీరు ఇంకా ఆలోచించని work కు కూడా వర్తించాల్సిన ఒకే fact అయితే, దాన్ని rules file లో ఉంచండి. Run make lint before committing. Never push to main. Handlers live in src/api/handlers/. ఒక్కోటి ఒక line గా ఉండాలి. ఒక entry steps గా విస్తరించిన క్షణం, అది fact గా ఉండడం ఆపి procedure గా మారుతుంది. అప్పుడు దాన్ని skill లోకి తరలించాలి.
Rules file సరిపోయే సందర్భం
Rules files అనేక ప్రదేశాల నుంచి load అవుతాయి. విస్తృత పరిధి నుంచి అత్యంత నిర్దిష్ట పరిధి వరకు క్రమం ఇలా ఉంటుంది: managed policy file, మీ వ్యక్తిగత ~/.claude/CLAUDE.md, project యొక్క ./CLAUDE.md లేదా ./.claude/CLAUDE.md, మరియు gitignored ./CLAUDE.local.md. కనుగొన్న అన్ని files ఒకదానిని మరొకటి override చేయకుండా కలిపి చదవబడతాయి. మీ working directoryకి దగ్గరగా ఉన్న files చివరగా చదవబడతాయి.
v2.1.277 నుంచి Claude Code AGENTS.md ను కూడా చదువుతుంది. అయితే defaultగా మీ working directoryలో లేదా దాని పైస్థాయి directoriesలో CLAUDE.md, .claude/CLAUDE.md లేదా CLAUDE.local.md ఏదీ లేనప్పుడు మాత్రమే అది చదవబడుతుంది. మీ repositoryలో రెండూ ఉంటే, Claude CLAUDE.md files మాత్రమే చదువుతుంది. అందువల్ల పరస్పరం భిన్నంగా మారే రెండు copies నిర్వహించవద్దు.
ln -s AGENTS.md CLAUDE.mdవిజయం సాధించినప్పుడు symlink ఏ outputను చూపదు. ఒక session ప్రారంభించి, /context all ను run చేయండి. తరువాత Memory files కింద CLAUDE.md కనిపిస్తుందో నిర్ధారించండి. అది అక్కడ జాబితాలో లేకపోతే, agent దాన్ని ఎప్పుడూ చూడలేదు. అప్పుడు wording మార్చడం వల్ల ప్రయోజనం ఉండదు. Claude-specific lines కూడా కావాలంటే import form ఉపయోగించి, వాటిని import కింద ఉంచండి.
@AGENTS.md
## Claude Code
Use plan mode for changes under `src/billing/`.ఇక్కడ ఒక ముఖ్యమైన చిక్కు ఉంది. @path imports contextను save చేయవు. Refer చేసిన fileతో పాటు imported file launch సమయంలో expand చేసి load చేయబడుతుంది. ఇది గరిష్ఠంగా four hops వరకు జరుగుతుంది. 600-line rules fileను six importsగా విభజించడం మనుషులకు నిర్వహణను సులభం చేస్తుంది. కానీ token costలో అసలు ఎలాంటి మార్పూ ఉండదు. Layout నిర్ణయించే ముందు AGENTS.md మరియు దాని మానవుల కోసం ఉద్దేశించిన సమాన file వెనుక ఉన్న conventions చదవడం ఉపయోగకరం.
ఖర్చును తగ్గించేది .claude/rules/ కు paths field జోడించడం. paths frontmatter ఉన్న rule file, patternsలో ఒకదానికి సరిపోయే fileను agent తాకినప్పుడు మాత్రమే load అవుతుంది.
---
paths:
- "src/api/**/*.ts"
---
# API rules
- Every endpoint validates its input.
- Use the standard error response shape.paths field లేని rule launch సమయంలో .claude/CLAUDE.md తో సమాన priorityతో load అవుతుంది. అందువల్ల ఉపయోగకరమైన విధానం ఇలా ఉంటుంది: చిన్న unconditional rules ఉంచండి. ఒక directoryలో మాత్రమే వర్తించే విషయాలకు paths list జోడించండి.
మీకు ఒక skill అవసరమైనప్పుడు
skill అనేది దానిలో SKILL.md ఉన్న directory. వ్యక్తిగత skills ~/.claude/skills/<name>/SKILL.md లో ఉంటాయి. అవి మీ machine లోని ప్రతి project కు వర్తిస్తాయి. Project skills .claude/skills/<name>/SKILL.md లో ఉంటాయి. అవి repository తో పాటు వస్తాయి. ఇతర file లాగే pull request లో వాటిని review చేయవచ్చు.
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.ఆ file లో skill అమలయ్యే ముందు context లో ఉండే ఏకైక భాగం description. అందువల్ల అది రెండు పనులు చేస్తుంది. Skill ఏమి చేస్తుందో ఇది చెబుతుంది. దాన్ని ఎప్పుడు ఉపయోగించాలో కూడా ఇది చెబుతుంది. "Helps with deploys" వంటి description ఉంటే, request తో సరిపోల్చడానికి model కు ఏ సమాచారం ఉండదు. అందువల్ల skill నిశ్శబ్దంగా అమలు కాదు. చివరకు skills పనిచేయవని మీరు భావిస్తారు.
Directory పేరు command అవుతుంది. అందువల్ల పై ఉదాహరణలో మీకు /summarize-changes లభిస్తుంది. Personal లేదా project skill లో directory పేరు కంటే భిన్నంగా ఉండే frontmatter name ఉంటే, / menu చూపించే command ను అది నిర్దేశిస్తుంది. అయితే అదే పేరును మరొక command ఇప్పటికే ఉపయోగిస్తే ఈ నియమం వర్తించదు. Directory పేరు ద్వారా skill ను ఇప్పటికీ invoke చేయవచ్చు.
Skill ను invoke చేసిన తర్వాత, దాని rendered content conversation లోకి ఒకే message గా ప్రవేశిస్తుంది. Session మిగిలినంత కాలం అది అక్కడే ఉంటుంది. తరువాతి turns లో Claude Code ఆ file ను మళ్లీ చదవదు. ఒక్కసారి మాత్రమే చేయాల్సిన steps బదులుగా నిరంతరం వర్తించే instructions రాయండి. Body ను సంక్షిప్తంగా ఉంచండి. ఆ దశ నుంచి ప్రతి line ప్రతి request పై మళ్లీ మళ్లీ ఖర్చవుతుంది. Auto-compaction తర్వాత Claude Code ప్రతి skill యొక్క ఇటీవలి invocation ను మళ్లీ జతచేస్తుంది. ప్రతి skill లోని మొదటి 5,000 tokens ను కలిపి 25,000 tokens budget లో ఉంచుతుంది. ఒకే session లో అనేక పెద్ద skills ను invoke చేస్తే, పాత skills పూర్తిగా తొలగించబడతాయి. అందుకే దీర్ఘమైన conversation తర్వాత skill ప్రాధాన్యం కోల్పోయినట్లు అనిపించవచ్చు. దాన్ని మళ్లీ invoke చేస్తే తిరిగి వస్తుంది. Procedure-heavy skill ఈ trade-off ను స్పష్టంగా చూపిస్తుంది: unlazy skill మరియు దాని Depth Tree పద్ధతి gates మరియు plan file కోసం నిజమైన context ను వినియోగిస్తుంది. దానికి బదులుగా పని ముందుగానే పూర్తయిందని ప్రకటించకుండా ఉండే agent ను అందిస్తుంది. అదే procedure ఒకటి కంటే ఎక్కువ codebase లకు వర్తిస్తే, file ను copy చేయడం బదులుగా అనేక repositories మధ్య ఒకే skill ను share చేయండి.
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 option గా parse చేస్తుంది. అప్పుడు అది దాన్ని తిరస్కరిస్తుంది.
claude mcp list
claude mcp get notionclaude mcp add ఒక Added ... line తో నిర్ధారిస్తుంది. ఇది configuration disk కు రాయబడిందని మాత్రమే చెబుతుంది. నిజమైన స్థితిని claude mcp list చెబుతుంది. ఇది ప్రతి server పక్కన health status ను ముద్రిస్తుంది: ✔ Connected, ! Needs authentication లేదా ✘ Failed to connect. Failure status అంటే Claude Code ఆ server ను చేరుకోలేకపోయిందని అర్థం. List command విఫలమైందని కాదు. Session లో /mcp ప్రతి server కు ఇదే వివరాలతో పాటు tool count ను కూడా చూపిస్తుంది.
MCP server కు చేసే ప్రతి call స్వతంత్రంగా ఉంటుంది. దానికి అవసరమైన మొత్తం సమాచారాన్ని అది తనతో తీసుకెళ్తుంది. అందుకే MCP server మీ మునుపటి అభ్యర్థనను గుర్తుంచుకోదు. ఇది మీరు స్వీకరించాల్సిన ఒక design choice తో వస్తుంది: నిల్వ చేయాల్సిన ఏ state అయినా server వెనుక, database లేదా file లో ఉండాలి. ఇప్పుడు దాని నిర్వహణ కూడా మీ బాధ్యత అవుతుంది.
MCP server అనేది మీరు అమలు చేయాల్సిన process
Vendor పోలికల్లో కనిపించని ఖర్చు ఇది. Skill అనేది ఒక file. MCP server అనేది ఎక్కడో అమలయ్యే software. ఆ స్థలం మీ VPS (virtual private server) అయితే, దాని uptime బాధ్యత మీపైనే ఉంటుంది.
Stdio server తక్కువ ఖర్చుతో కూడిన సందర్భం. Session ప్రారంభమైనప్పుడు Claude Code దాన్ని child processగా ప్రారంభిస్తుంది. Session ముగిసినప్పుడు అది ఆగిపోతుంది. Monitor చేయాల్సినది ఏదీ ఉండదు. స్వతంత్రంగా patch చేయాల్సిన schedule కూడా ఉండదు. 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.targetsudo systemctl daemon-reload
sudo systemctl enable --now notes-mcp
systemctl is-active notes-mcp
journalctl -u notes-mcp -n 50 --no-pagersystemctl is-active, active ను print చేయాలి. అది failed ను print చేస్తే, కారణం journalలో ఉంటుంది. మొదటిసారి అమలు చేసినప్పుడు కారణం దాదాపు ఎల్లప్పుడూ missing environment variable లేదా ఇప్పటికే మరొక process ఉపయోగిస్తున్న port అవుతుంది. ఇక్కడ Restart=on-failure ఐచ్ఛికం కాదు. ఎందుకంటే crash అయిన MCP server తనంతట తాను తెలియజేయదు. Agent మీ issue trackerను చదవలేనని చెప్పినప్పుడు మాత్రమే మీకు విషయం తెలుస్తుంది.
Processను 127.0.0.1 కు bind చేసి, దాని ముందు TLS (transport layer security)తో reverse proxy ఉంచండి. మీ databaseకు ప్రాప్యత కలిగి, authentication లేకుండా public portపై సమాధానం ఇచ్చే MCP server అంటే మీరు publicగా అందుబాటులో ఉంచిన database అన్నమాట. VPSపై MCP serverను అమలు చేయడం లో proxy, certificate, firewall అంశాలను సరిగ్గా వివరించారు.
తరచుగా చేయాల్సిన పనిని నిజాయితీగా లెక్కించండి. ఈ service security updatesను agentతో సంబంధం లేని స్వంత schedule ప్రకారం స్వీకరిస్తుంది. దాని OAuth token గడువు ముగుస్తుంది. అసౌకర్యమైన సమయంలో claude mcp list, ! Needs authentication ను print చేయడం ప్రారంభిస్తుంది. దాని credentials config fileలో లేదా Authorization headerలో ఉంటాయి. కాబట్టి ఇతర secretల మాదిరిగానే వాటినీ జాగ్రత్తగా నిర్వహించాలి. ఇది ప్రత్యేకంగా పరిశీలించాల్సిన పెద్ద విషయం: AI agentకు secrets అందకుండా ఉంచడం. Skillకు ఈ పనుల్లో ఏదీ ఉండదు.
మీరు build చేయడానికి ముందు ప్రత్యామ్నాయంతో పోల్చి నిర్ణయించండి. ప్రతిపాదిత server వెనుక ఉన్న data దాదాపు ప్రతి quarterకు ఒకసారి మాత్రమే మారితే, agent ఎక్కడ చూడాలో, fields అర్థం ఏమిటో చెప్పే skillను ఉపయోగించడం, నిరంతరం అమలులో ఉంచాల్సిన service కంటే తక్కువ ఖర్చుతో ఉంటుంది.
మీ స్వంత context ఖర్చును ఎలా కొలవాలి
అంచనా వేయడం ఆపి, session లోనే /context all ను అమలు చేయండి. ఇది ప్రస్తుత విభజనను చూపిస్తుంది: system prompt, memory files, tools, మరియు MCP servers. ప్రతి అంశానికి సంబంధించిన token పరిమాణాన్ని కూడా చూపిస్తుంది.
రెండు విషయాలను పరిశీలించండి. Memory files కింద మీరు ఆశిస్తున్న ప్రతి rules file కనిపిస్తుందో నిర్ధారించండి. ఏదైనా file కనిపించకపోతే agent దాన్ని చూడలేడు. అందువల్ల instructions పాటించకపోతే ముందుగా దీనిని తొలగించాల్సిన కారణంగా పరిగణించాలి. File కనిపిస్తున్నప్పటికీ rule ఇంకా skip అవుతుంటే కారణం పూర్తిగా వేరే చోట ఉంటుంది. అప్పుడు మీరు line ను మళ్లీ rewrite చేయడానికి ముందు agent చూడగలిగే instruction ను ఎందుకు దాటి వెళ్తుందో వివరించే కారణాలు పరిశీలించడం ఉపయోగకరం. తరువాత మీ servers ఎంత context ఖర్చు చేస్తున్నాయో చూడండి. నెలకు రెండుసార్లు మాత్రమే ఉపయోగించే server ఆ జాబితాలో అతిపెద్ద అంశాల్లో ఒకటిగా ఉంటే, /mcp లో దాన్ని off చేసి, అవసరమైన sessions కోసం మళ్లీ on చేయండి. ఏ విధంగానైనా configuration అలాగే భద్రంగా ఉంటుంది.
మీ account కోసం discovery cache on లో ఉంటే, మీరు ఇంతకు ముందు ఉపయోగించిన remote server cached 2h ago · connects on first use · 5 tools వంటి status ను చూపించవచ్చు. అంటే startup సమయంలో connect కాకుండా, Claude Code మునుపటి session నుంచి tool list ను చదివిందని అర్థం. Tool మొదటిసారి call చేసినప్పుడు అది connect అవుతుంది. మీ మొదటి message నుంచే tools అందుబాటులో ఉంటాయి. కాబట్టి సరిచేయాల్సిన సమస్య ఏదీ లేదు. gradual rollout ద్వారా మీకు enable చేయకపోతే cache default గా off లో ఉంటుంది. ప్రతి server startup సమయంలో connect కావాలంటే MCP_DISCOVERY_CACHE=0 ను set చేయండి. Cache on చేయాలంటే 1 ను set చేయండి. విస్తృత వివరాల కోసం Claude Code context window ను నిర్వహించడం compaction తర్వాత ఏవి మిగులుతాయో వివరిస్తుంది. ఆ tokens మీకు వాస్తవంగా ఎంత ఖర్చవుతాయో ఆ సంఖ్యలను డబ్బు విలువగా చూపిస్తుంది.
నా skill ఎందుకు ఎప్పుడూ trigger కావడం లేదు?
సాధారణ కారణం description. Skill అమలు కావడానికి ముందు context లో ఉన్న ఏకైక text అదే. అందులో పరిస్థితి పేర్కొనకపోతే ఏదీ match కాదు. Trigger ను sentence లోనే రాయండి: "వినియోగదారు ఏమి మారిందని అడిగినప్పుడు, commit message కోరినప్పుడు లేదా తమ diff ను review చేయమని అడిగినప్పుడు ఉపయోగించండి." అస్పష్టమైన వివరణలు ఎలాంటి error లేకుండా విఫలమవుతాయి. అందువల్ల ఈ సమస్యను గుర్తించడం కష్టం.
రెండవ కారణం frontmatter లోని typo. Claude Code లో ఇది కూడా ఎలాంటి error లేకుండా విఫలమవుతుంది. Field name hyphens సహా ఖచ్చితంగా సరిపోవాలి. గుర్తించని field ను Claude Code ఎలాంటి error చూపకుండా విస్మరిస్తుంది. Skill ను package చేసినప్పుడు లేదా claude.ai లేదా Skills API కు upload చేసినప్పుడు మాత్రమే స్పష్టమైన error కనిపిస్తుంది. అవి తక్కువ fields ను మాత్రమే అంగీకరిస్తాయి మరియు మిగిలినవాటిని నేరుగా తిరస్కరిస్తాయి:
Unexpected key(s) in SKILL.md frontmatter: argument-hint. Allowed properties are: allowed-tools, compatibility, description, license, metadata, nameమూడవ కారణం location. Project skills మీ working directory లోని .claude/skills/ మరియు repository root వరకు ఉన్న ప్రతి parent directory నుంచి load అవుతాయి. మీరు ప్రారంభించిన స్థానానికి కింద ఉన్న nested directories లోని skills launch సమయంలో load కావు. Agent ఆ subdirectory లోని file ను మొదటిసారి చదివినప్పుడు లేదా edit చేసినప్పుడు అవి కనిపిస్తాయి. అప్పటివరకు అవి autocomplete లో కనిపించవు మరియు పేరుతో invoke చేయలేరు.
ఈ silent failure కు MCP సమానమైనది .mcp.json entry లో url ఉండి, type లేకపోవడం. type లేని ప్రతి entry ను Claude Code stdio server గా పరిగణిస్తుంది. అందువల్ల అది ఆ entry ను skip చేసి ఇలా నివేదిస్తుంది:
MCP server "notes" has a "url" but no "type"; add "type": "http" (or "sse" / "ws") to this entryమూడు విధానాలను కలిపి ఉపయోగించడం
ఈ మూడు విధానాలు ఒకే స్థానం కోసం పోటీ పడవు. సమర్థవంతమైన అమరికలో, ఖర్చు తక్కువగా ఉండే చోట ప్రతి విధానాన్ని ఉపయోగిస్తారు. అన్ని సందర్భాల్లో వర్తించే కొన్ని నియమాలను rules file లో ఉంచాలి. procedures ను skills లో ఉంచాలి; అవి వర్తించినప్పుడు మాత్రమే load అవుతాయి. ముందుగా ఊహించలేని contents ఉన్న systems కు ఒక MCP server ను, అవసరమైతే రెండు MCP servers ను, connect చేయాలి. వీటిలో మొదటి విధానం గురించి మీ mental model ను ఇంకా రూపొందిస్తున్నట్లయితే, agent skill వాస్తవానికి ఏమిటి అనే వివరణలో format ను వివరంగా చూడవచ్చు.
ఏదైనా విషయం ఎక్కడ ఉండాలో నిర్ణయించడానికి ఒక test చాలాసార్లు సరిపోతుంది. దాన్ని తొలగించి, కొత్త session ప్రారంభించి, agent కు task ఇవ్వండి. Agent కేవలం నెమ్మదిగా పనిచేస్తే, అది skill లో ఉండాలి. Agent ధైర్యంగా తప్పు సమాధానం ఇస్తే, అది rules file లో ఉండాలి. Agent కు ఆ information అసలు లభించకపోతే, మీకు server అవసరం. ఆ server ను ఎల్లప్పుడూ up గా ఉంచే plan కూడా ఇప్పుడు అవసరం.
FAQ
నేను skill రాయాలా లేదా MCP server ఏర్పాటు చేయాలా?
ఒక invocation నుంచి తదుపరి invocation వరకు సమాచారం మారుతుందా అనే దాని ఆధారంగా నిర్ణయించండి. Issue tracker, database లేదా dashboard వంటి, మరొకరు మార్చగల live state ను agent చదవాల్సి ఉంటే MCP server అవసరం. ఎందుకంటే record మారిన వెంటనే మీరు రాసి ఉంచిన సమాచారం stale అవుతుంది. ఒకసారి సమాధానం రాసి ఉంచినా ఆరు వారాల తర్వాత కూడా అది సరైనదిగా ఉంటే skill రాయండి. Skill అనేది git లోని ఒక file. దాన్ని నడపడానికి process, expose చేయడానికి port లేదా patch schedule అవసరం ఉండదు. అందువల్ల సాధ్యమైన ప్రతిసారి ఇది తక్కువ ఖర్చుతో కూడిన ఎంపిక.
MCP servers ఇప్పటికీ నా context window ను నింపుతాయా?
గతంతో పోలిస్తే చాలా తక్కువగా నింపుతాయి. ప్రస్తుత Claude Code లో tool search default గా enabled ఉంటుంది. అందువల్ల session ప్రారంభంలో tool names మరియు server యొక్క instructions field మాత్రమే load అవుతాయి. Claude వాటి కోసం search చేసినప్పుడు full schemas fetch అవుతాయి. ANTHROPIC_BASE_URL ద్వారా ఏర్పాటు చేసిన LLM gateway వెనుక ఉన్న sessions కు కూడా ఇది వర్తిస్తుంది. ఇది v2.1.304 నుంచి అందుబాటులో ఉంది. ENABLE_TOOL_SEARCH=false ఉపయోగించినప్పుడు, "alwaysLoad": true కు set చేసిన server కోసం, Claude Opus 4 మరియు Sonnet 4 కంటే పాత model పై, upfront loading ఇప్పటికీ జరుగుతుంది. Google Cloud's Agent Platform లో 4.5 generation కంటే పాత model అంటే ఇదే. Azure లో hosted Microsoft Foundry deployments లో కూడా upfront loading జరుగుతుంది. మీరు ఏ పరిస్థితిలో ఉన్నారో చూడటానికి /context all run చేయండి. ఎందుకంటే పాత comparison posts లోని numbers upfront loading ను ఆధారంగా చేసుకుంటాయి.
Claude Code AGENTS.md ను చదువుతుందా?
అవును. ఇది v2.1.277 నుంచి జరుగుతోంది. అయితే default గా మీ working directory లో లేదా దాని పైభాగంలోని directoryల్లో CLAUDE.md, .claude/CLAUDE.md లేదా CLAUDE.local.md ఏదీ లేనప్పుడు మాత్రమే ఇది జరుగుతుంది. మీ repository లో రెండూ ఉంటే Claude CLAUDE.md files ను మాత్రమే చదువుతుంది. అందువల్ల రెండు copies ఉంచకుండా, ఒకదాన్ని మరొకదానికి point చేయండి. సాధారణ symlink కోసం ln -s AGENTS.md CLAUDE.md run చేయండి. లేదా CLAUDE.md యొక్క మొదటి line లో @AGENTS.md ఉంచి, దాని కింద Claude-specific instructions జోడించండి. తరువాత session ప్రారంభించి, CLAUDE.md Memory files కింద కనిపిస్తుందో నిర్ధారించడానికి /context all run చేయండి.
Session మధ్యలో నా skill ప్రభావం చూపడం ఎందుకు ఆగిపోయింది?
సాధారణ కారణం auto-compaction. Conversation ను summarize చేసినప్పుడు Claude Code ప్రతి skill యొక్క అత్యంత ఇటీవలి invocation ను మళ్లీ జతచేస్తుంది. ప్రతి skill లోని మొదటి 5,000 tokens వరకు ఉంచుతుంది. అన్ని skills కోసం కలిపి budget 25,000 tokens. ఇటీవలి invocation చేసిన skill నుంచి ఈ budget నింపబడుతుంది. అందువల్ల మీరు అనేక పెద్ద skills ను invoke చేసి ఉంటే పాత skills పూర్తిగా తొలగించబడతాయి. దాని పూర్తి content ను తిరిగి ఉంచడానికి skill ను మళ్లీ invoke చేయండి.
ప్రతి session లో పొడవైన rules file load కాకుండా ఎలా ఆపాలి?
అప్పుడప్పుడు మాత్రమే అవసరమయ్యే భాగాలను paths field కలిగిన .claude/rules/ files లోకి తరలించండి. అప్పుడు agent matching file ను తాకినప్పుడు మాత్రమే ప్రతి file load అవుతుంది. File ను @path imports గా విభజించడం సహాయపడదు. ఎందుకంటే imported files expand చేయబడి, వాటిని reference చేసిన file తో పాటు launch సమయంలో load అవుతాయి. Multi-step procedure గా ఉన్నది standing fact కాకపోతే దాన్ని skill గా మార్చండి. ఎందుకంటే skill body invoke చేసే వరకు ఎటువంటి ఖర్చు ఉండదు.