Claude Code session செலவு மற்றும் வேகம் குறைய

Claude Code session மெதுவாகவும் அதிக செலவாகவும் மாறுவதைத் தடுப்பது எப்படி

ஒவ்வொரு turn-இன் போதும் முழு context-உம் மீண்டும் அனுப்பப்படுவதாலும், அந்த context தொடர்ந்து அதிகரிப்பதாலும் Claude Code session மெதுவாகவும் அதிக செலவாகவும் மாறுகிறது. இதைச் சரிசெய்ய ஒரு குறிப்பிட்ட வரிசையில் hygiene முறைகளைப் பின்பற்ற வேண்டும். Window-இல் உள்ளத் தரவுகளைப் பார்க்க /context கட்டளையைப் பயன்படுத்தவும். ஒவ்வொரு request-இன் போதும் கட்டணம் வசூலிக்கப்படும் தரவுகளை நீக்கவும். தொடர்பற்ற பணிகளுக்கு இடையே /clear பயன்படுத்தவும். ஒரு நீண்ட பணிக்குள் (long task) ஒரு instruction-ஐப் பயன்படுத்த /compact பயன்படுத்தவும். தொடர்ச்சியான stints-ஆகப் பணியாற்றுங்கள், ஏனெனில் cold prompt cache காரணமாகக் குறைந்த செலவில் நடக்கும் read, நீங்கள் கூறிய அனைத்தையும் மீண்டும் எழுதும் (full re-write) முழுச் செலவாக மாறிவிடும்.

ஏன் meter இயங்குகிறது என்பதற்கான விளக்கம் agent session-இன் பின்னால் உள்ள token meter பகுதியில் உள்ளது.

எதையும் மாற்றுவதற்கு முன் /context-ஐப் படிக்கவும்

Window-இல் என்ன இருக்கிறது என்பதை ஊகிப்பதைத் தவிர்க்கவும். Claude Code அதை உங்களுக்குத் தெரிவிக்கும்.

/context [all] தற்போதைய context usage-ஐ ஒரு colored grid-ஆகக் காட்டும்; context-அதிகமாக உள்ள tools மற்றும் memory bloat ஆகியவற்றிற்கான optimization suggestions-களையும் இது வழங்கும்; fullscreen mode-இல் all ஒவ்வொரு item-இன் breakdown-ஐ விரிவுபடுத்தும். முடிவுகளை ஐந்து buckets-களாகப் புரிந்துகொள்ளவும்.

• The system prompt. Claude Code-இன் சொந்த harness instructions. இது session முழுவதும் நிலையானது (fixed).
• Tool definitions. Agent அழைக்கக்கூடிய ஒவ்வொரு tool-இன் schema, இணைக்கப்பட்டுள்ள ஒவ்வொரு MCP (Model Context Protocol) server உட்பட.
• Memory files. session தொடங்கும் போது ஏற்றப்படும் CLAUDE.md மற்றும் auto memory.
• Files and tool results. படிக்கப்பட்ட ஒவ்வொரு file மற்றும் உங்கள் commands மூலம் திரையில் காட்டப்பட்ட அனைத்தும்.
• Message history. உங்கள் கேள்விகள் மற்றும் அதன் பதில்கள்.

முதல் மூன்று அம்சங்கள், session முழுவதும் ஒவ்வொரு request-க்கும் செலுத்த வேண்டிய நிலையான வரி (fixed tax) போன்றது. கடைசி இரண்டு அம்சங்கள் வளர்ந்து கொண்டே இருக்கும். தொடக்கத்தில் நிலையான வரியைக் குறைத்துக்கொள்ளுங்கள்; வளரும் பகுதிகளைத் தொடர்ந்து நிர்வகிக்கவும்.

Window நிரம்பிவிட்டதைக் குறிக்க இரண்டு strings உள்ளன:

Context exceeds the 200k-token limit by 94k tokens — run /compact or /clear to continue.
Context is 94k tokens past the 200k-token compaction window — run /compact to reduce usage.

முதல் ஒன்று ஒரு hard limit, இது இருந்தால் request நிராகரிக்கப்படும்; இதற்கான API (application programming interface) error Prompt is too long என்று இருக்கும். இரண்டாவது ஒரு compaction window, இது 1 million token model-இல் model-இன் உண்மையான context window-ஐ விடக் குறைவாக இருக்கலாம். இதைக் கடந்தும் requests வெற்றிகரமாக முடியும், எனவே இது நிராகரிப்பை விட ஒரு warning மட்டுமே.

Paid plan-இல், /usage மற்ற பாதியைச் சேர்க்கிறது; long context அல்லது cache misses போன்ற நடத்தைகளைக் கண்டறிந்து, சமீபத்திய usage-ஐ தனிப்பட்ட skills, subagents மற்றும் MCP servers-களுடன் தொடர்புபடுத்திக் காட்டும்.

CLAUDE.md என்பது ஒரு நிரந்தர வரி (tax), எனவே அதைச் சுருக்கமாக வைத்திருங்கள்

உங்கள் CLAUDE.md session தொடங்கும் போது context-இல் ஏற்றப்பட்டு அங்கேயே இருக்கும். அதில் விரிவான deployment procedure இருந்தால், நீங்கள் ஒரு test file-இல் typo-வைச் சரிசெய்யும் போதும் அந்த tokens பயன்பாட்டில் இருக்கும். Anthropic-இன் வழிகாட்டுதலின்படி, அத்தியாவசியத் தகவல்களை மட்டும் சேர்த்து, அந்த file-ஐ 200 lines-களுக்குக் குறைவாக வைத்திருக்க வேண்டும்.

Procedures-களை skills-களுக்கு மாற்றவும். ஒரு skill அழைக்கப்படும் போது மட்டுமே load ஆகும், எனவே வாரத்திற்கு இருமுறை நீங்கள் பயன்படுத்தும் workflow மற்ற நாட்களில் எந்தச் செலவையும் ஏற்படுத்தாது. compaction செய்த பிறகு skills-களுக்குத் தனி budget உண்டு: bodies மீண்டும் ஏற்றப்படும் (re-injected), ஒரு skill-க்கு அதிகபட்சமாக 5,000 tokens மற்றும் மொத்தம் 25,000 tokens மட்டுமே அனுமதிக்கப்படும்; இதில் பழைய தகவல்கள் முதலில் நீக்கப்படும் (dropped). Truncation செயல்முறை file-இன் தொடக்கப் பகுதியை அப்படியே வைத்திருக்கும், எனவே மிக முக்கியமான instructions-களை SKILL.md-இன் தொடக்கத்தில் வைக்கவும்.

Compaction செய்த பிறகு எது தப்பித்துத் தங்குக்கிறதோ, அதை வைத்தே ஒரு instruction எங்கு இருக்க வேண்டும் என்பதைத் தீர்மானிக்கலாம்.

• System prompt மற்றும் output style ஆகியவை மாறாது, ஏனெனில் அவை message history-இல் இடம்பெறாது.
• Project-root CLAUDE.md, unscoped rules மற்றும் auto memory ஆகியவை disk-லிருந்து மீண்டும் ஏற்றப்படும்.
• paths: frontmatter கொண்ட ஒரு rule, அந்தத் தொடர்புடைய file மீண்டும் படிக்கப்படும் வரை நீக்கப்படும்.
• ஒரு subdirectory-இல் உள்ள nested CLAUDE.md, அந்த subdirectory-இல் உள்ள ஒரு file மீண்டும் படிக்கப்படும் வரை நீக்கப்படும்.
• Hooks பாதிக்கப்படாது, ஏனெனில் ஒரு hook code-ஆக இயங்குவதால் அது context-க்குள் வராது.

எனவே நீங்கள் நம்பியிருக்கும் ஒரு rule, project-root CLAUDE.md-இல் இருக்க வேண்டும்: Claude Code முதலில் பழைய tool outputs-களை நீக்கிவிட்டு பிறகு summarize செய்யும், எனவே உரையாடலின் தொடக்கத்தில் உள்ள instructions விடுபட வாய்ப்புள்ளது. /memory மூலம் memory-ஐத் திருத்தலாம் (edit). Claude Code session தொடங்கும் போது ஏற்றப்பட்ட நகலையே (copy) வைத்திருக்கும், எனவே session-இன் நடுவில் செய்யப்படும் trim, prompt cache-ஐப் பாதுகாக்கும் மற்றும் அடுத்த /clear, /compact அல்லது restart வரும் வரை அமலுக்கு வராது.

பணிகளுக்கு இடையே /clear, ஒரே பணிக்கூள் உள்ளே /compact

இவை இரண்டும் ஒன்றுபோலத் தோன்றினாலும், இவற்றின் செலவுகள் முற்றிலும் மாறுபட்டவை.

/clear [name] என்பது காலியான context உடன் ஒரு புதிய உரையாடலைத் தொடங்கும். இது எந்த request-ஐயும் அனுப்பாது, எனவே இதற்குச் செலவு இல்லை. /resume picker-இல் முந்தைய உரையாடலைக் குறிக்க ஒரு பெயரைப் பயன்படுத்தவும்; /reset மற்றும் /new ஆகியவை அதன் இணைப் பெயர்கள் (aliases) ஆகும். நீங்கள் தொடர்பற்ற ஒரு பணிக்கு மாறும்போது உடனடியாக இதைப் பயன்படுத்தவும், இல்லையெனில் பழைய பணி ஒவ்வொரு புதிய செய்தியின் போதும் மீண்டும் அனுப்பப்பட்டு, மீண்டும் கட்டணம் வசூலிக்கப்படும்.

/compact [instructions] ஒரே உரையாடலைத் தொடரும்போதே context-ஐச் சுருக்கி இடவசதி செய்யும்: இது இதுவரை உள்ள வரலாற்றைச் சுருக்கி (summarize) அதை மாற்றீடு செய்யும். தொடர்ச்சி தேவைப்படும் ஒரு நீண்ட பணிக்குள் இதைப் பயன்படுத்தவும்.

/compact-க்கு எப்போதும் ஒரு instruction-ஐ வழங்கவும். வெறும் /compact என்பது நீங்கள் வேலையின் எந்தப் பகுதியைத் தொடர வேண்டும் என்று தெரியாத ஒரு default prompt மூலம் சுருக்கச் செய்யும். instruction வழங்கப்பட்டால் மட்டுமே அது தொடர்ச்சியைக் காக்கும்:

/compact focus on the auth bug fix
/compact keep only the plan and the diff

ஒவ்வொரு முறையும் ஒரே காரணத்திற்காக நீங்கள் compact செய்கிறீர்கள் என்றால், உங்கள் project-இன் CLAUDE.md பகுதியில் ஒரு # Compact instructions heading-இன் கீழ் ஒரு standing instruction-ஐ வைக்கவும். ஒரு புதிய session-இல் /compact என்பது Not enough messages to compact. என்று அச்சிடப்படும், இதன் பொருள் இன்னும் வரலாறு (history) இல்லை என்பதாகும்.

இங்கு இரண்டு செலவுகள் குழப்பமடையலாம். summarization request என்பது உங்கள் prefix-ஐப் பகிர்ந்து கொள்ளும், எனவே அது வரலாற்றை மீண்டும் process செய்வதற்குப் பதிலாக ஏற்கனவே உள்ள cache-ஐப் படிக்கும், அதன் பெரும்பாலான நேரம் summary உருவாக்குவதற்கே செலவாகும். ஒரு பெரிய context-ஐ compact செய்வது என்பது இன்னும் ஒரு பெரிய request தான், ஏனெனில் சுருக்கப்படும் உரையாடலே input ஆக இருக்கும். compaction-க்கு அடுத்த முறை மெதுவாக இருக்காது: இது மிகக் குறுகிய prompt-க்காக cache-ஐ மீண்டும் கட்டமைக்கும்.

இரண்டு மலிவான commands உள்ளன. /rewind [description] என்பது code மற்றும் உரையாடலை ஒரு checkpoint-க்குத் திரும்பக் கொண்டு செல்லும்; நீங்கள் முற்றிலுமாகத் தவிர்க்க விரும்பும் ஒரு path-க்கு, compact செய்வதை விட இது சிறந்தது, ஏனெனில் இது ஏற்கனவே cached ஆக உள்ள ஒரு prefix-க்குத் திரும்புகிறது. /recap என்பது வரலாற்றை மாற்றீடு செய்வதற்குப் பதிலாக, ஒரு summary-ஐ command output ஆகச் சேர்க்கிறது, இதனால் cached prefix அப்படியே இருக்கும்.

தொடர்ச்சியாக automatic compaction இயங்கினால் இது அச்சிடப்படும்:

Autocompact is thrashing: the context refilled to the limit...

Compaction வெற்றிகரமாக முடிந்தது, ஆனால் ஒரு file அல்லது tool output பலமுறை window-வை நிரப்பிவிட்டது, எனவே Claude Code மீண்டும் முயற்சிக்கத் தவிர்த்துவிட்டது. ஒரு பெரிய file-ஐ line ranges மூலம் வாசிப்பதன் மூலமோ, பெரிய output-ஐத் தவிர்க்கும் வகையில் focus உடன் /compact இயக்குவதன் மூலமோ, அந்த வேலையை ஒரு subagent-க்கு மாற்றுவதன் மூலமோ அல்லது முந்தைய உரையாடல் முடிந்துவிட்டது என்றால் /clear பயன்படுத்துவதன் மூலமோ இதைச் சரிசெய்யலாம்.

MCP servers are fixed overhead

நீங்கள் இணைக்கும் ஒவ்வொரு MCP server-உம் முழு session முழுவதும் ஒவ்வொரு request-க்கும் கூடுதல் overhead-ஐ சேர்க்கிறது. நீங்கள் அந்த tool-ஐ பயன்படுத்தினாலும் இல்லாவிட்டாலும், அதற்கான செலவு (cost) ஏற்படும்.

Claude Code இதை எளிதாக்குகிறது. MCP tool definitions இயல்பாகவே deferred நிலையில் இருக்கும். எனவே, Claude ஒரு குறிப்பிட்ட tool-ஐப் பயன்படுத்தும் வரை, அதன் பெயர்கள் மட்டுமே context-க்குள் வரும். உங்கள் servers உண்மையில் எவ்வளவு செலவைச் செய்கின்றன என்பதைப் பார்க்க /context-ஐ இயக்கவும், இன்று நீங்கள் பயன்படுத்தப் போகாத server-ஐ நீக்க /mcp disable <name>-ஐ இயக்கவும். நீங்கள் your own MCP servers on a VPS இயக்கினால், ஒரு server எத்தனை tools-களைக் காட்ட வேண்டும் என்பதையும் இதே கணக்கீடு தீர்மானிக்கிறது.

ஒரு session தொடங்கியவுடன் இதைச் செய்யவும். Definitions deferred நிலையில் இருக்கும் வரை, ஒரு server-ஐ இணைப்பது அல்லது துண்டிப்பது conversation-இல் மட்டும் சேர்க்கப்படும், மேலும் cache அப்படியே இருக்கும். ஆனால், tool search ஆஃப் செய்யப்பட்டிருந்தாலோ அல்லது ஒரு server deferral முறையிலிருந்து விலக்கமடங்கியிருந்தாலோ, definitions prefix-க்குள் लोड செய்யப்படும். அவ்வாறு நடக்கும்போது, அடுத்த request அனைத்தையும் மீண்டும் படிக்க வேண்டியிருக்கும்.

Context-க்குள் நுழைவதற்கு முன் verbose tool output-ஐ filter செய்யவும்

ஒரு tool result input-ஆகச் சேமிக்கப்படுகிறது. ஒவ்வொரு அடுத்த turn-இலும் அந்த input மீண்டும் அனுப்பப்படும். 20,000 tokens கொண்ட ஒரு test run-ன் output, ஒருமுறை மட்டும் ஏற்படும் செலவு அல்ல: அது context window-வை விட்டு வெளியேறும் வரை ஒவ்வொரு turn-இலும் நீங்கள் மீண்டும் அதற்காகச் செலவிட வேண்டியிருக்கும்.

மூலத்திலிருந்தே (source) filter செய்யவும். Claude பார்க்கும் முன்பே ஒரு test run-ஐ அதன் failures-களாக மட்டும் குறைக்கும் ஒரு hook, அந்தப் பெரிய output-ஐ சில நூறு tokens-களாக மாற்றுகிறது. இது தற்போதைய turn மற்றும் அதன் ஒவ்வொரு resend-க்கும் பொருந்தும்:

npm test 2>&1 | grep -E "FAIL|Error:" | head -40

Hooks எப்போதும் context-க்குள் வராது, ஏனெனில் அவை code-ஆக இயங்குகின்றன. ஒரு tool-ன் output திரையில் (screen) இருந்து அதிகமாகச் சென்றால், இந்த முறையைப் பயன்படுத்தவும். இதே தர்க்கம் (logic) 3,000-line கொண்ட file-க்கும் பொருந்தும்: உங்களுக்குத் தேவையான line range-ஐ மட்டும் கேட்கவும், ஏனெனில் முழு file-உம் window-க்குள் தங்கிவிடும்.

Agent வாசிக்கும் எல்லையைத் தீர்மானிக்கவும், அதிகப்படியான வேலைகளைப் பிரித்து வழங்கவும்

ஒரு file மற்றும் அதன் அறிகுறியைக் (symptom) குறிப்பிடும் prompt அந்த file-ஐ வாசிக்கும். ஒரு project-ஐச் சீரமைக்கக் கேட்கும் open request, agent பொருத்தமானது எனக் கருதும் அனைத்தையும் வாசிக்கும். அவ்வாறு வாசிக்கப்படும் தகவல்கள் அனைத்தும் context window-விலேயே இருக்கும்.

அதிகப்படியான வேலைகளை (verbose work) ஒரு subagent-க்குப் பிரித்து வழங்கவும். Test runs மற்றும் log processing ஆகிய இரண்டும் அதிக context-ஐப் பயன்படுத்துகின்றன; ஒரு subagent அந்த output-ஐ அதன் சொந்த window-விலேயே வைத்துக்கொண்டு, ஒரு summary-ஐ மட்டும் வழங்கும். இதில் உள்ள சவால்கள் (tradeoff): முதல் முறை அழைக்கும்போது subagent தனக்கென ஒரு cache-ஐ உருவாக்கும் (no hits), மேலும் subscription இருந்தாலும் ஐந்து நிமிட cache lifetime-ஐயே பயன்படுத்தும். Delegation முறையானது உங்கள் main context-ஐப் பாதுகாப்பாகப் பராமரிக்கிறது. இது எப்போதும் மொத்த token எண்ணிக்கையைக் குறைக்காது.

The cache clock: work in stints

Prompt caching-ன் மூலம் மீண்டும் அனுப்புதல் (resend) செலவு குறைவாகிறது: prefix-ஐ வாசிக்க (read) base input rate-ன் 0.1x மட்டுமே செலவாகும்; அதை எழுத (write) 1.25x செலவாகும், அல்லது ஒரு மணிநேர lifetime-க்கு 2x செலவாகும். ஒவ்வொரு முறையும் பயன்படுத்தும் போது கூடுதல் செலவின்றி அந்த entry refresh ஆகும், எனவே கடைசி பயன்பாட்டிலிருந்து (last use) clock தொடங்கும்.

உங்களுக்கு எந்த lifetime கிடைக்கும் என்பது நீங்கள் எவ்வாறு authenticate செய்கிறீர்கள் என்பதைப் பொறுத்தது. எனவே "உங்கள் cache ஐந்து நிமிடங்களில் expires ஆகிவிடும்" என்ற பொதுவான கூற்று தவறானது.

• Claude subscription வைத்திருந்தால், Claude Code தானாகவே ஒரு மணிநேர lifetime-ஐக் கோரும்.
• உங்கள் plan-ன் limit முடிந்த பிறகு usage credits பயன்படுத்தினால், அந்த பயன்பாட்டிற்கு கட்டணம் வசூலிக்கப்படும், எனவே அது ஐந்து நிமிடங்களாகக் குறையும்.
• API key அல்லது cloud provider பயன்படுத்தினால், அது ஐந்து நிமிடங்களாகவே இருக்கும். ENABLE_PROMPT_CACHING_1H=1 ஒரு மணிநேர lifetime-ஐத் தேர்ந்தெடுக்கும் (opts into), ஆனால் FORCE_PROMPT_CACHING_5M=1 அதை மீண்டும் ஐந்து நிமிடங்களாகக் குறைக்கும்.

இரண்டு நிலைகளுக்கும் ஒரே மாதிரியான அறிவுரை: தொடர்ச்சியான stints-ல் வேலை செய்யுங்கள். ஏனெனில் lifetime காலக்கெடுவைத் தாண்டி நீங்கள் இடைவெளி (idle gap) விட்டால், அடுத்த முறை நீங்கள் முழு accumulated prefix-ஐயும் மீண்டும் எழுத வேண்டியிருக்கும். ஒரு detached Claude Code session in tmux idle நிலையில் இருக்கும்போது எந்தச் செலவும் செய்யாது; idle நேரத்தினால் கிடைக்கும் warm cache-ஐத் தான் நீங்கள் இழக்கிறீர்கள்.

நீங்கள் வேலை செய்து கொண்டிருக்கும் போதே சில செயல்கள் cache-ஐ நீக்கிவிடும்: models மாற்றுவது, effort level மாற்றுவது, fast mode ஆன் செய்வது, MCP server-ஐ இணைப்பது அல்லது துண்டிப்பது, plugin-ஐ enable அல்லது disable செய்வது, ஒரு tool-ஐ மறுப்பது (denying), compacting மற்றும் Claude Code-ஐ upgrade செய்வது. /model என்பது பொதுவான ஆச்சரியமான விஷயம், ஏனெனில் ஒவ்வொரு model-க்கும் தனித்தனி cache உண்டு. எனவே உள்ளடக்கங்கள் (content) ஒன்றாக இருந்தாலும், அடுத்த request-ல் cache hits இல்லாமல் முழு history-யும் வாசிக்கப்படும்.

Files edit செய்வது, CLAUDE.md edit செய்வது, skills மற்றும் commands-ஐ அழைப்பது, /recap இயக்குவது, rewinding மற்றும் subagent-ஐ உருவாக்குவது ஆகிய அனைத்தும் cache-ஐத் தக்கவைக்கும். இது ஒரு machine மற்றும் ஒரு directory-க்கு மட்டுமே பொருந்தும், எனவே வெவ்வேறு directory-களில் உள்ள இரண்டு sessions-களால் ஒன்றையொன்று cache மூலம் தொடர்பு கொள்ள முடியாது.

Caching சரியாக வேலை செய்கிறதா என்பதைப் பார்க்க, current_usage-ஐப் படிக்கவும். cache_creation_input_tokens cache write rate-ல் எழுதப்பட்டது; cache_read_input_tokens சாதாரண input rate-ன் பத்தில் ஒரு பங்கில் (one tenth) வழங்கப்பட்டது. அதிகப்படியான read-to-creation ratio ஆரோக்கியமானது. ஒவ்வொரு முறையும் creation அதிகமாகவே இருந்தால், உங்கள் prefix-ல் ஏதோ ஒன்று தொடர்ந்து மாறிக் கொண்டிருக்கிறது என்று அர்த்தம்.

பெரிய context window இதைக் குணப்படுத்துமா?

பகுதியாகவே. தற்போதைய பல models 1 million token context window-ஐ ஆதரிக்கின்றன. பெரிய limit-களிலும் compaction ஒரே மாதிரியாகவே செயல்படுகிறது. முழு prompt-உம் ஒவ்வொரு turn-இடமும் மீண்டும் அனுப்பப்படுவதாலும், அதற்கேற்ப billing செய்யப்படுவதாலும் இதன் economics மாறுவதில்லை. ஒரு பெரிய window நீங்கள் எப்போது செயல்பட வேண்டும் என்பதைத் தீர்மானிக்கிறது; hygiene அதன் செலவைத் தீர்மானிக்கிறது. சிக்கல் ceiling-ல் இல்லை, bill-ல் இருந்தால், உங்கள் வேலை முறைக்கு எந்த Claude plan பொருந்தும் என்பதைப் பொறுத்தே நீங்கள் dollars செலவு செய்கிறீர்களா அல்லது plan allowance பயன்படுத்துகிறீர்களா என்பது அமையும்.

API-இல் Context editing மற்றும் compaction ஆகியவை வெவ்வேறானவை

நீங்கள் [build-ai-agent-with-claude-vps|Messages API மூலம் உங்கள் சொந்த agent-ஐ உருவாக்குகிறீர்கள்] என்றால், slash commands இருக்காது; அவற்றை நீங்களே செயல்படுத்த வேண்டும். இரண்டு server-side அம்சங்கள் இந்த வேலையைச் செய்கின்றன, ஆனால் அவை இரண்டும் ஒன்றல்ல.

Context editing என்பது உரையாடல் வரலாறு (conversation history) வளர வளர, அதில் உள்ள குறிப்பிட்ட உள்ளடக்கத்தைத் தேர்ந்தெடுத்து நீக்குகிறது. நீக்கப்பட்ட ஒவ்வொரு இடத்திலும் placeholder text-ஐப் பயன்படுத்துகிறது, இதன் மூலம் Claude ஒரு விஷயம் நீக்கப்பட்டதை அறியும். இது ஒரு beta அம்சம்: anthropic-beta: context-management-2025-06-27-ஐ அனுப்பி, context_management.edits என்பதன் கீழ் strategies-களை configure செய்ய வேண்டும். clear_tool_uses_20250919 என்பது tool results-களை நீக்கும், clear_thinking_20251015 என்பது thinking blocks-களை நிர்வகிக்கும். இதன் trigger மதிப்பு 100,000 input tokens ஆகவும், keep மதிப்பு கடைசி 3 tool uses ஆகவும், clear_tool_inputs மதிப்பு false ஆகவும் default ஆக இருக்கும்; இதனால் inputs அப்படியே இருக்கும், results மட்டுமே நீக்கப்படும்.

Compaction என்பது ஒரு summary-ஐ உருவாக்கி, முழு உரையாடல் வரலாற்றையும் அதற்குப் பதிலாக மாற்றுகிறது. இதுவும் ஒரு beta அம்சம்: anthropic-beta: compact-2026-01-12-ஐ அனுப்பி, compact_20260112 என்ற edit type-ஐப் பயன்படுத்த வேண்டும். இதன் trigger மதிப்பு {"type": "input_tokens", "value": 150000} ஆக default ஆக இருக்கும், மேலும் அதன் மதிப்பு குறைந்தது 50,000 ஆக இருக்க வேண்டும்.

Compaction-இல் agents-களைப் பாதிக்கும் ஒரு handoff rule உள்ளது. இதன் response, summary-ஐக் கொண்ட compaction content block-இல் தொடங்கி, அதைத் தொடர்ந்து சாதாரண text block-ஐக் கொண்டிருக்கும். அடுத்தடுத்த requests-களில் அந்த block-ஐ நீங்கள் மீண்டும் அனுப்ப வேண்டும்; அவ்வாறு செய்யும்போது, API அதற்கு முன் உள்ள அனைத்து content blocks-களையும் நீக்கிவிடும். நடைமுறையில்: வெறும் text-ஐ மட்டும் அனுப்பாமல், response.content முழுவதையும் இணைக்கவும்.

Anthropic-இன் ஆவணங்களின்படி, நீண்ட உரையாடல்களில் context-ஐ நிர்வகிக்க server-side compaction முதன்மையான வழியாகும்; எதை நீக்க வேண்டும் என்பதைக் கட்டுப்படுத்த context editing பயன்படுகிறது. முதலில் model support-ஐச் சரிபார்க்கவும். தற்போதைய Opus, Sonnet மற்றும் Fable models compaction-ஐ ஆதரிக்கின்றன; claude-haiku-4-5 ஆதரிக்காது. compaction தொடர்பான நேரடிப் பட்டியலை அந்தப் பக்கத்தில் காணலாம். எந்த beta அம்சமும் Claude Code-இன் /compact அம்சத்தை இயக்கவில்லை; அதன் ஆவணங்களின்படி, client அனுப்பும் ஒருமுறை மட்டும் செய்யப்படும் summarization request மட்டுமே அது.

FAQ

எனது Claude Code session நீண்ட நேரம் இயங்கும்போது ஏன் வேகம் குறைகிறது மற்றும் செலவு அதிகரிக்கிறது?

ஒவ்வொரு turn-இன் போதும் முழு உரையாடலும் மீண்டும் அனுப்பப்படுவதால் இது நிகழ்கிறது. நாள் முழுவதும் திறந்திருக்கும் ஒரு session-இல் நீங்கள் கேட்கும் ஒரு வரி கேள்வி கூட, அன்றைய முழு உரையாடலையும் உள்ளடக்கியது. Prompt caching பயன்பாட்டில் இருக்கும்போது, read-க்கான செலவு base input rate-இல் 0.1x ஆகக் குறைவாக இருக்கும். ஒரு turn-இல் cache miss ஆனால், அதே prefix 1.25x என்ற விகிதத்தில் மீண்டும் எழுதப்படும். window-இல் எது அதிக இடத்தை ஆக்கிரமித்துள்ளது என்பதைப் பார்க்க /context கட்டளையைப் பயன்படுத்தவும். அதன் செயல்பாட்டு முறையைப் பற்றி அறிய Claude Code session எவ்வாறு கட்டணம் வசூலிக்கிறது என்பதைப் படிக்கவும்.

Claude Code-இல் /clear மற்றும் /compact ஆகியவற்றிற்கு இடையிலான வேறுபாடு என்ன?

/clear என்பது காலியான context-உடன் ஒரு புதிய உரையாடலைத் தொடங்கும். இது எந்த request-ஐயும் அனுப்பாததால், செலவு ஏதும் இருக்காது; தொடர்பற்ற பணிகளுக்கு (unrelated tasks) இதுவே சரியான தேர்வாகும். /compact என்பது அதே உரையாடலைத் தொடரச் செய்து, history-ஐ ஒரு summary-ஆல் மாற்றுகிறது; எனவே ஒரு நீண்ட பணியின் உள்ளே இதுவே சரியான தேர்வாகும். /compact keep only the plan and the diff-இல் உள்ளது போல, ஒரு குறிப்பிட்ட இலக்கை (focus) வழங்கவும், ஏனெனில் அந்த instruction தான் எதெல்லாம் இருக்க வேண்டும் என்பதைத் தீர்மானிக்கிறது.

எனது Claude Code context window-இல் எதெல்லாம் பயன்படுகின்றன என்பதை நான் எப்படிப் பார்ப்பது?

/context கட்டளையை இயக்கவும், அல்லது ஒவ்வொரு பொருளுக்கான விரிவான விவரங்களுக்கு /context all கட்டளையைப் பயன்படுத்தவும். இது system prompt, tool definitions, MCP servers, memory files மற்றும் history ஆகியவற்றை ஒரு வண்ணமயமான grid-ஆகக் காட்டும்; மேலும் context-ஐ அதிகம் பயன்படுத்தும் tools மற்றும் memory bloat ஆகியவற்றிற்கான பரிந்துரைகளையும் வழங்கும். கட்டணத் திட்டத்தில் (paid plan), /usage சமீபத்திய பயன்பாட்டைத் தனித்தனி skills, subagents மற்றும் MCP servers ஆகியவற்றோடு இணைத்துக் காட்டும்.

compaction செய்வதற்குப் பதிலாக 1 million token context window-ஐ நான் பயன்படுத்த வேண்டுமா?

பெரிய window என்பது சிக்கலைத் தீர்ப்பதற்குப் பதிலாகத் தள்ளிப்போடுகிறது. Opus 4.8 மற்றும் Sonnet 5 உட்பட பல தற்போதைய models 1 million token context window-இல் இயங்குகின்றன, அங்கு compaction இதேபோலவே செயல்படும். ஒவ்வொரு turn-இன் போதும் முழு prompt-உம் மீண்டும் அனுப்பப்படுவதால் கட்டணம் வசூலிக்கப்படும்; எனவே 400,000-token உரையாடல் என்பது அது context window-க்குள் அடங்கினாலும் இல்லாவிட்டாலும் செலவு மிக்கதுதான்.

Claude API-இல் context editing மற்றும் compaction ஆகியவற்றிற்கு இடையிலான வேறுபாடு என்ன?

Context editing என்பது பழைய உள்ளடக்கங்களை (முக்கியமாக tool results)த் தேர்ந்தெடுத்து நீக்குகிறது; நீக்கப்பட்ட இடத்திற்குப் பதிலாக placeholder text-ஐ விட்டுவைக்கிறது, இதன் மூலம் Claude அந்தத் தகவல் நீக்கப்பட்டதை அறியும். Compaction என்பது ஒரு summary-ஐ உருவாக்கி, முழு history-ஐயும் அதைக் கொண்டு மாற்றுகிறது. Anthropic-இன் ஆவணங்கள், நீண்ட நேர உரையாடல்களுக்கு compaction-ஐ முதன்மை உத்தியாகக் குறிப்பிடுகின்றன, மேலும் context editing-ஐ நுணுக்கமான (fine-grained) விருப்பமாக முன்வைக்கின்றன. இவை இரண்டும் தனித்தனி தலைப்புகளைக் கொண்ட beta அம்சங்கள், மேலும் இவை Claude Code-இன் /compact என்பதிலிருந்து தனித்துவமானவை.