Claude memory அம்சத்திற்கு கூடுதல் கட்டணம் உண்டா?

Claude-ன் memory அம்சங்களுக்கு கூடுதல் கட்டணம் உண்டா?

Claude-ன் memory அம்சங்களுக்கு என்று தனியாக எந்தக் கட்டணமும் இல்லை. Anthropic-ன் வெளியிடப்பட்ட கட்டணங்கள் ஒரு மில்லியன் input tokens மற்றும் ஒரு மில்லியன் output tokens-க்கு என நிர்ணயிக்கப்பட்டுள்ளன. இதனுடன் prompt caching-க்கு கூடுதல் கட்டணங்கள் உண்டு, ஆனால் இதில் 'memory token' என்று எதுவும் இல்லை. Claude API (application programming interface)-ல் memory-ஐச் சேமிப்பதற்கு எந்தக் கட்டணமும் இல்லை, ஏனெனில் memory கருவி client-side-ல் இயங்குகிறது மற்றும் அந்தத் தரவு நீங்கள் வைத்திருக்கும் storage-ல் சேமிக்கப்படுகிறது.

இருப்பினும், memory பயன்பாடு உங்கள் கட்டணத்தில் பிரதிபலிக்கும். ஏனெனில், ஒரு நினைவில் கொள்ளப்பட்ட தகவல் Claude படிக்கும் request-க்குள் இருக்கும்போது மட்டுமே அது பதிலை மாற்றும். நினைவில் கொள்வது என்பது அந்தத் தகவலை மீண்டும் அனுப்புவதைக் குறிக்கும். அந்த உரை input tokens-ஆக வந்து சேரும், அதற்கு அந்த model-ன் வழக்கமான input கட்டணம் வசூலிக்கப்படும். இரண்டு காரணிகள் கட்டணத்தைத் தீர்மானிக்கின்றன: ஒவ்வொரு முறையும் நீங்கள் மீண்டும் அனுப்பும் நினைவக உரையின் tokens எண்ணிக்கை மற்றும் அந்த உரை prompt cache-லிருந்து வழங்கப்பட முடியுமா என்பது.

Pro அல்லது Max சந்தாவில் (subscription) உங்களுக்கு token அடிப்படையில் கட்டணம் வசூலிக்கப்படுவதில்லை, எனவே memory உங்கள் பணத்தை விட, உங்கள் பயன்பாட்டு ஒதுக்கீட்டை (usage allowance) செலவிடும். இதற்கான செயல்முறை ஒன்றுதான், அலகு (unit) மட்டுமே மாறுகிறது. அந்த ஒதுக்கீடு வரையறுக்கப்பட்டது என்பதால், ஒவ்வொரு முறையும் எவ்வளவு memory-ஐப் பயன்படுத்த வேண்டும் என்று முடிவெடுப்பதற்கு முன் Claude Pro-ன் கட்டணம் மற்றும் அதன் வரம்புகள் எங்கே முடிகின்றன என்பதைத் தெரிந்துகொள்வது அவசியம். Claude Enterprise-ன் கட்டமைப்பு வேறுபட்டது, ஏனெனில் இது seat கட்டணத்திற்கு மேலாக API கட்டணத்தில் ஒவ்வொரு token-ஐயும் கணக்கிடுகிறது. எனவே, அதிகப்படியான memory பயன்பாடு ஒதுக்கீட்டிற்குப் பதிலாக மீண்டும் பணமாக மாறும். memory-ஐக் குறைப்பதன் மூலம் உங்கள் பயன்பாட்டை ஒரு சிறிய திட்டத்தின் வரம்பிற்குள் கொண்டு வர முடிந்தால், Max-லிருந்து Pro-விற்கு மாறுவது பயனுள்ள நடவடிக்கையாக இருக்கும். இந்த மாற்றம் நீங்கள் ஏற்கனவே பணம் செலுத்திய காலத்தின் முடிவில் அமலுக்கு வரும். நீங்கள் Anthropic-ன் திட்டங்களுக்கு இடையே அல்லாமல், வெவ்வேறு நிறுவனங்களுக்கு இடையே ஒப்பிட்டுப் பார்க்கிறீர்கள் என்றால், தற்போதைய விலையில் Claude-ன் திட்டங்களை ChatGPT-யுடன் ஒப்பிட்டுப் பார்ப்பது சிறந்த தொடக்கமாக இருக்கும்.

ஒவ்வொரு Claude தளத்திலும் "memory" என்பதன் பொருள்

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

Claude API-ல் உள்ள memory tool. நீங்கள் tools வரிசையில் (array) ஒரு உள்ளீட்டைச் சேர்க்கிறீர்கள், மேலும் கோப்பு செயல்பாடுகளை (file operations) உங்கள் சொந்தக் குறியீட்டில் செயல்படுத்துகிறீர்கள்.

{"type": "memory_20250818", "name": "memory"}

ஆகஸ்ட் 2026 நிலவரப்படி, இந்த கருவி Messages API-ல் எந்த beta header-ம் இன்றி, Claude 4 மற்றும் அதற்குப் பிந்தைய மாடல்களில் பொதுவான பயன்பாட்டிற்கு கிடைக்கிறது. இது client-side முறையில் இயங்குகிறது: Claude view /memories போன்ற ஒரு செயல்பாட்டைக் கேட்கிறது, உங்கள் handler நீங்கள் கட்டுப்படுத்தும் சேமிப்பகத்தில் அதை இயக்குகிறது, மேலும் நீங்கள் tool_result தொகுதியில் முடிவைத் திருப்பித் தருகிறீர்கள். Anthropic கோப்பைச் சேமித்து வைப்பதில்லை, எனவே சேமிப்பகக் கட்டணம் ஏதுமில்லை. அதற்குப் பதிலாக, நீங்கள் round trip-க்கு பணம் செலுத்துகிறீர்கள். கருவி வரையறை (tool definition) ஒவ்வொரு கோரிக்கையிலும் அனுப்பப்படுகிறது, மேலும் திரும்பப் பெறப்படும் கோப்பின் உள்ளடக்கம் அந்த இடத்திலிருந்து உரையாடலில் தொடர்ந்து இருக்கும்.

Anthropic அந்த மேல்நிலைச் செலவின் (overhead) நிலையான பகுதியை வெளியிடுகிறது. Claude Opus 5-ல் auto கருவித் தேர்வைப் பயன்படுத்தும்போது, ஆகஸ்ட் 2026-ன் ஆவணப்படி, கருவி பயன்பாட்டு system prompt 286 tokens ஆகும். ஏதேனும் ஒரு கருவி (memory அல்லது பிற) இருக்கும்போது, ஒவ்வொரு கோரிக்கைக்கும் இது ஒருமுறை வசூலிக்கப்படும்.

Claude Code. ஒவ்வொரு அமர்வின் தொடக்கத்திலும் இரண்டு வழிமுறைகள் ஏற்றப்படுகின்றன. CLAUDE.md கோப்புகள் நீங்கள் எழுதும் வழிமுறைகளைக் கொண்டுள்ளன. Auto memory என்பது Claude தனக்காக எழுதும் குறிப்புகளை ~/.claude/projects/<project>/memory/-ன் கீழ் வைத்திருக்கிறது. MEMORY.md-ன் முதல் 200 வரிகள் அல்லது 25KB மட்டுமே ஏற்றப்படும் (எது முதலில் வருகிறதோ அது), மேலும் அதற்கு அருகில் உள்ள தலைப்பு கோப்புகள் தொடக்கத்திலன்றி, தேவைப்படும்போது வாசிக்கப்படுகின்றன. தொடக்கத்தில் ஏற்றப்படும் அனைத்தும் அந்த அமர்வில் வரும் ஒவ்வொரு பிந்தைய கோரிக்கையின் முன்னொட்டாக (prefix) மாறுகின்றன. அமர்வுகள் இடையே Claude Code எவ்வாறு memory-ஐ நினைவுபடுத்துகிறது என்பது கோப்பு வாரியான ஏற்றும் வரிசையை விளக்குகிறது.

இணையத்தில் Claude. claude.ai-ல், memory என்பது நீங்கள் உரையாடும்போது Claude எழுதி புதுப்பிக்கும் உள்ளீடுகளின் தொகுப்பாகும், ஒவ்வொரு project-க்கும் தனித்தனி memory இடம் உள்ளது. Settings > Memory என்பதில் என்ன சேமிக்கப்பட்டுள்ளது என்பது பட்டியலிடப்படும், மேலும் அங்குள்ள toggle மூலம் Pause memory அல்லது Reset memory ஆகியவற்றைத் தேர்ந்தெடுக்கலாம். இந்த தளம் சந்தா (subscription) அடிப்படையில் கட்டணம் வசூலிக்கிறது, எனவே இங்குள்ள memory பயன்பாட்டு வரம்புகளை (usage limits) செலவிடும்.

நினைவகத்தில் உள்ள உரை ஏன் உள்ளீட்டு டோக்கன்களாகக் கணக்கிடப்படுகிறது

Messages API ஒரு stateless அமைப்பாகும். இது அழைப்புகளுக்கு இடையில் எதையும் சேமித்து வைப்பதில்லை. எனவே, ஒவ்வொரு முறையும் உங்கள் client முழு உரையாடலையும் அனுப்புகிறது, model அதை மீண்டும் முழுமையாகப் படிக்கிறது. நினைவகம் (memory) இந்த விதிக்கு விதிவிலக்கல்ல. அது அதே கோரிக்கையில் உள்ள மற்றொரு உரைத் தொகுதியாகும்.

இந்தக் கட்டமைப்பு எந்தவொரு பதிலிலும் உள்ள usage பொருளில் தெளிவாகத் தெரியும்.

"usage": {
  "input_tokens": 412,
  "cache_creation_input_tokens": 0,
  "cache_read_input_tokens": 18240,
  "output_tokens": 236
}

input_tokens என்பது cache-லிருந்து படிக்கப்படாத அல்லது அதை உருவாக்கப் பயன்படுத்தப்படாத டோக்கன்களை மட்டுமே கணக்கிடுகிறது. நடைமுறையில், இது கடைசி cache breakpoint-க்கு பிறகுள்ள டோக்கன்களைக் குறிக்கும். ஒரு கோரிக்கையின் மொத்த உள்ளீடு என்பது cache_read_input_tokens கூட்டல் cache_creation_input_tokens கூட்டல் input_tokens ஆகும். மூன்று சுற்றுகளுக்கு முன்பு Claude திறந்த ஒரு நினைவகக் கோப்பு, அதன் பிறகு ஒவ்வொரு சுற்றிலும் அந்த மொத்த உள்ளீட்டிற்குள் அமர்ந்திருக்கும். cached prefix சரியாக இருக்கும்போது அது cache_read_input_tokens-ன் கீழ் வரும், அது சரியாக இல்லாதபோது input_tokens-ன் கீழ் வரும். ஒரே உரை, ஆனால் இரண்டு வெவ்வேறு விலைகள். உள்ளீடு மற்றும் வெளியீட்டு டோக்கன்களுக்கு வெவ்வேறு விலைகள் உள்ளன, மேலும் நினைவகம் எப்போதும் உள்ளீட்டுப் பக்கத்தில் மட்டுமே கணக்கிடப்படும்.

உங்கள் பயன்பாட்டில் இந்த எண்களை எங்கே பார்ப்பது

எந்தவொரு வலைப்பதிவிலும் உள்ள புள்ளிவிவரங்களை அப்படியே எடுத்துக்கொள்ள வேண்டாம், இந்த பதிவும் அதற்கு விதிவிலக்கல்ல. உங்கள் சொந்த memory block-ஐ நீங்களே அளவிடுங்கள். Token counting இலவசமானது மற்றும் அதற்கு தனி rate limit உள்ளது, எனவே இந்த அளவீட்டிற்கு எந்த செலவும் இல்லை.

curl https://api.anthropic.com/v1/messages/count_tokens \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "content-type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "system": "You are a scientist",
    "messages": [{"role": "user", "content": "Hello, Claude"}]
  }'

இதற்கான பதில் ஒரு எண் மட்டுமே, உதாரணமாக { "input_tokens": 14 }. உங்கள் memory text-ஐ system field-ல் ஒட்டி ஒருமுறை இயக்கவும், அதை நீக்கிவிட்டு மீண்டும் ஒருமுறை இயக்கவும். இந்த இரண்டிற்கும் உள்ள வித்தியாசமே ஒவ்வொரு முறையும் அந்த memory-க்காக நீங்கள் செலவிடும் தொகையாகும். இதில் இரண்டு எச்சரிக்கைகள் உள்ளன. இந்த எண்ணிக்கை ஒரு தோராயமான மதிப்பீடு மட்டுமே; Anthropic தனது சொந்த system optimizations-க்காகச் சேர்க்கும் கூடுதல் tokens உங்களுக்குக் கட்டணமாக விதிக்கப்படாது. மேலும், நீங்கள் பயன்படுத்தப்போகும் அதே model-ஐக் கொண்டு கணக்கிடுங்கள், ஏனெனில் Claude 4.7 மற்றும் அதற்குப் பிந்தைய பதிப்புகள் புதிய tokenizer-ஐப் பயன்படுத்துகின்றன, இது அதே உரைக்கு சுமார் 30 சதவீதம் கூடுதல் tokens-ஐ உருவாக்குகிறது.

Claude Code-க்குள், எந்தவொரு curl கட்டளையும் இன்றி இதே கேள்விக்கு விடை கிடைக்கும்.

• /context தற்போது என்ன லோட் ஆகியுள்ளது என்பதைக் காட்டும், இதில் memory files-உம் அடங்கும். எனவே நீங்கள் எதையும் தட்டச்சு செய்வதற்கு முன்பே window-வில் அவற்றின் பங்களிப்பை அறியலாம்.
• /memory உங்கள் CLAUDE.md கோப்புகளைப் பட்டியலிட்டு, auto memory கோப்புறையைத் திறக்கும்.
• /usage session-ன் மொத்த விவரங்களை அச்சிடும், இதில் cache reads மற்றும் cache writes ஆகியவையும் அடங்கும்.
• Status line-ல் context window பயன்பாட்டைத் தொடர்ந்து பார்க்கலாம், இதனால் பயன்பாடு அதிகரிக்கும்போது அதை உடனுக்குடன் கவனிக்க முடியும்.

/usage session block இதைப் போல இருக்கும்:

Total cost:            $0.55
Total duration (API):  6m 20s
Total duration (wall): 6h 33m 10s
Total code changes:    0 lines added, 0 lines removed
Usage by model:
   claude-sonnet-4-6:  1.2k input, 5.3k output, 940.0k cache read, 50.0k cache write ($0.55)

கடைசி வரியைக் கவனமாகப் படிக்கவும். 940.0k cache read என்பது உரையாடல் மற்றும் memory என அனைத்தும் ஒவ்வொரு முறையும் cache rate-ல் மீண்டும் அனுப்பப்படுவதைக் குறிக்கிறது. 1.2k input என்பது புதிதாகச் சேர்க்கப்பட்ட பகுதி மட்டுமே. Claude Code அந்த டாலர் மதிப்பை உள்ளூர் விலைப் பட்டியலைக் கொண்டு கணக்கிடுகிறது, எனவே உங்களுக்குக் கிடைக்கும் தள்ளுபடிகளை இது கணக்கில் கொள்ளாது, மேலும் இது உங்கள் invoice-லிருந்து மாறுபடலாம். Claude Console-ல் உள்ள Usage பக்கமே அதிகாரப்பூர்வமான எண்ணாகும்.

பிறகு, ஒப்பீட்டை நேரடியாகச் செய்யுங்கள். இரண்டு புதிய session-களில் ஒரே தொடக்கக் கேள்வியைக் கேளுங்கள்; ஒன்றில் auto memory இயக்கப்பட்டிருக்க வேண்டும், மற்றொன்றில் அது அணைக்கப்பட்டிருக்க வேண்டும்.

CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 claude

ஒவ்வொன்றிலும் /context-ஐ இயக்கி, memory files பதிப்பை ஒப்பிட்டுப் பாருங்கள். எந்தவொரு வேலையும் தொடங்குவதற்கு முன்பே, ஒவ்வொரு session-ன் தொடக்கத்திலும் உங்கள் memory-க்காகச் செலவாகும் தொகையே இந்த வித்தியாசம். Claude Code token பயன்பாடு எங்கே செல்கிறது என்பதன் முழுமையான விளக்கம் என்பதை அந்த இரண்டு எண்களுடன் ஒப்பிட்டுப் படிப்பது பயனுள்ளதாக இருக்கும்.

ஒரு மில்லியன் tokens-க்கு memory-ஐ மீண்டும் இயக்குவதற்கான (replaying) செலவு எவ்வளவு?

Prompt caching-ஆல்தான் ஒரே memory block ஒரு முறைக்கு அடுத்த முறை பத்து மடங்கு அதிக செலவை ஏற்படுத்த முடியும். Anthropic, cache கட்டணங்களை ஒவ்வொரு model-ன் அடிப்படை input விலையின் மடங்குகளாக வெளியிடுகிறது; எனவே, டாலர் விலைகள் மாறினாலும் இந்த விகிதம் மாறாமல் இருக்கும்.

[
  {
    "label": "Base input",
    "price_multiple": 1
  },
  {
    "label": "5 minute cache write",
    "price_multiple": 1.25
  },
  {
    "label": "1 hour cache write",
    "price_multiple": 2
  },
  {
    "label": "Cache read",
    "price_multiple": 0.1
  }
]

ஒரு cache read-ன் விலை அடிப்படை input விலையை விட 0.1 மடங்கு ஆகும். 5 நிமிட ஆயுட்காலம் கொண்ட ஒரு entry-ஐ எழுதுவதற்கு அடிப்படை விலையை விட 1.25 மடங்கும், 1 மணிநேர ஆயுட்காலம் கொண்டதற்கு 2 மடங்கும் செலவாகும். Anthropic இதற்கான break-even புள்ளியைத் தெளிவாகக் கூறுகிறது: 5 நிமிட கால அளவில் ஒருமுறை cache read செய்தாலே caching லாபகரமானது; 1 மணிநேர கால அளவில் இரண்டு முறை cache read செய்த பிறகு இது லாபகரமானது. Prompt caching-க்கான break-even புள்ளி என்பது memory-ஐ எங்கு சேமிப்பது என்று முடிவெடுக்கும் முன் நீங்கள் செய்ய வேண்டிய கணக்கீடு ஆகும்.

இந்த மடங்குகள் replay எண்ணிக்கையை எளிய கணிதமாக மாற்றுகின்றன. கீழே உள்ள பகுதி மேலே குறிப்பிடப்பட்ட வெளியிடப்பட்ட மடங்குகளைக் கொண்டு கணக்கிடப்பட்டதே தவிர, நேரடி workload-ன் அளவீடு அல்ல. இது 100 சுற்றுகள் கொண்ட ஒரு session-ல் ஒரு memory block-ன் விலையை, சாதாரண அடிப்படை input விலையில் கணக்கிடப்படும் tokens-ன் எண்ணிக்கையாகக் காட்டுகிறது.

[
  {
    "label": "4,000 tokens, never cached",
    "base_rate_equivalent_tokens": "400,000"
  },
  {
    "label": "4,000 tokens, 1 write and 99 reads",
    "base_rate_equivalent_tokens": "44,600"
  },
  {
    "label": "1,000 tokens, 1 write and 99 reads",
    "base_rate_equivalent_tokens": "11,150"
  }
]

100 சுற்றுகளிலும் cache-ஐ அடையாத (miss) 4,000 token கொண்ட ஒரு memory block, 400,000 அடிப்படை-விகித tokens-க்கு சமமான கட்டணத்தை வசூலிக்கும். அதே block, ஒருமுறை 5 நிமிட cache write மற்றும் 99 cache reads-க்கு உட்படுத்தப்பட்டால், அது 44,600 அளவுக்குக் கட்டணத்தை வசூலிக்கும். அதன் அளவை நான்கில் ஒரு பங்காகக் குறைத்து, caching-ஐத் தொடர்ந்தால், அது 11,150 அளவுக்குக் கட்டணத்தை வசூலிக்கும். அந்த 3 வரிசைகளிலும் அம்சம் மாறவில்லை. replay செய்யும் விதம் மட்டுமே மாறியது. இவை இன்னும் பணமாக அல்லாமல் token எண்ணிக்கையாகவே உள்ளன, மேலும் token எண்ணிக்கையை உங்கள் மாதக் கட்டணமாக மாற்றுவது என்பது உங்கள் model-ன் ஒரு மில்லியன் tokens-க்கான விலையுடன் ஒருமுறை பெருக்க வேண்டிய கணக்கீடு ஆகும். அந்த விலை நீங்கள் பயன்படுத்தும் model-ஐப் பொறுத்தது, எனவே agent Claude Fable 5-ல் இயங்கினால், அதன் வெளியிடப்பட்ட ஒரு மில்லியன் tokens-க்கான விலைகள் மற்றும் அது பொருத்தமான பணிகள் ஆகியவற்றிலிருந்து தொடங்கவும்.

இரண்டாவது வரிசை, 99 பிந்தைய கோரிக்கைகளும் cache entry உயிர்ப்புடன் இருக்கும்போதே வந்துவிடுவதாகக் கருதுகிறது. இந்த அனுமானத்தில்தான் பெரும்பாலான உண்மையான கட்டணக் கணக்கீடுகள் தவறாகின்றன.

ஓய்வுக்குப் பிறகு அதே கேள்விக்கு ஏன் அதிக கட்டணம் வசூலிக்கப்படுகிறது?

Cache entry-க்கு ஒரு காலாவதி காலம் உண்டு. அதை எழுதும் அல்லது படிக்கும் கோரிக்கையின் போது அந்தக் கடிகாரம் தொடங்குகிறது. இயல்பான கால அளவு 5 நிமிடங்கள் ஆகும். 1 மணிநேர விருப்பத்திற்கு மேலே காட்டப்பட்டுள்ள 2x write கட்டணம் வசூலிக்கப்படும். Claude Code-ல் சந்தா (subscription) வைத்திருப்பவர்களுக்கு இந்த கால அளவு ஒரு மணிநேரம்; usage credits-ஐப் பயன்படுத்தத் தொடங்கினால் அது 5 நிமிடங்களாகக் குறையும். API key அல்லது cloud provider-ல் இது இயல்பாகவே 5 நிமிடங்கள் ஆகும். ENABLE_PROMPT_CACHING_1H=1-ஐ அமைப்பதன் மூலம், usage credits-ல் இருக்கும்போதும் ஒரு மணிநேர காலாவதி காலத்தைத் தக்கவைக்கலாம்.

எனவே, மதிய உணவு இடைவேளைக்கு முன் திறந்து வைத்திருந்த session-ல் ஒரு வரியிலான கேள்வியைக் கேட்கும்போது, நீங்கள் இல்லாத நேரத்தில் cache entry காலாவதியாகிவிடுவதால் அது அதிக செலவை ஏற்படுத்துகிறது. memory உட்பட முழு prefix-ம் மீண்டும் அடிப்படை input விகிதத்தில் செயலாக்கப்பட்டு, மீண்டும் cache-ல் எழுதப்படுகிறது. அந்த இடைவேளையின் நீளமே விலையைத் தீர்மானிக்கிறது.

இதை நீங்கள் நம்புவதற்குப் பதிலாக உறுதிப்படுத்திக் கொள்ளலாம். Pro, Max, Team அல்லது Enterprise திட்டங்களில், /usage பிரிப்பு (breakdown), சமீபத்திய பயன்பாட்டில் 10 சதவீதம் அல்லது அதற்கு மேல் பங்களிக்கும் எந்தவொரு செயல்பாட்டையும் சுட்டிக்காட்டும். நீண்ட context மற்றும் cache misses ஆகிய இரண்டும் அங்கு பெயரிடப்பட்டுத் தோன்றும். API-ல், அமைதியான காலத்திற்குப் பிறகு வரும் முதல் கோரிக்கையின் போது cache_creation_input_tokens மீண்டும் அதன் முழு prefix அளவிற்கு உயர்வதைக் கவனிக்கலாம்.

எது தற்காலிகமாக cache-ஐ செல்லாததாக்குகிறது

Cached prefix வரிசைப்படுத்தப்பட்டுள்ளது: முதலில் tools, அடுத்து system, இறுதியில் messages. ஒரு நிலையில் செய்யப்படும் மாற்றம், அந்த நிலையையும் அதற்குப் பின் வரும் அனைத்தையும் செல்லாததாக்கிவிடும். ஒரு tool வரையறையைத் திருத்தினால், முழு cache-உம் நீக்கப்படும். System prompt-ஐத் திருத்தினால், system மற்றும் message cache நீக்கப்படும்.

System prompt-ல் நினைவகத்தை வைத்துக்கொண்டு, agent கற்றுக்கொள்ளும் ஒவ்வொரு முறையும் அதை மாற்றும் பயனர்களுக்கு இது ஒரு சிக்கலாகும். ஒவ்வொரு முறை மாற்றும்போதும் அதற்குப் பின்னால் உள்ள அனைத்தும் நீக்கப்படுவதால், அடுத்த கோரிக்கையின்போது முழுமையாக மீண்டும் எழுத வேண்டியிருக்கும். நிலையான தகவல்களை முன்னால் வைத்து அவற்றை மாற்றாமல் இருக்கவும்; அடிக்கடி மாறும் தகவல்களை message பட்டியலின் இறுதியில் வைக்கவும், அப்போதுதான் அதை நீக்குவது செலவற்றதாக இருக்கும்.

இன்னொரு அமைதியான தோல்வியும் உள்ளது. ஒவ்வொரு model-க்கும் குறைந்தபட்ச cache செய்யக்கூடிய prefix அளவு உள்ளது: ஆகஸ்ட் 2026-ல் வெளியிடப்பட்ட தரவுகளின்படி, Claude Opus 5-க்கு 512 tokens, Claude Sonnet 5-க்கு 1,024 tokens, Claude Haiku 4.5-க்கு 4,096 tokens. இந்த அளவுக்குக் குறைவாக cache செய்வது குறித்து Anthropic-ன் ஆவணங்கள் தெளிவாகக் கூறுகின்றன: "இந்த எண்ணிக்கையை விடக் குறைவான tokens-ஐ cache செய்யக் கோரினால், அது cache செய்யப்படாமலேயே செயல்படுத்தப்படும், எந்தப் பிழையும் காட்டப்படாது." எனவே, cache_control எனக் குறிக்கப்பட்ட ஒரு சிறிய நினைவகக் கோப்பு எந்தப் பயனும் தராது, அமைதியாகச் செயல்படும். இதற்கான அறிகுறியாக, உங்கள் prompt-ல் breakpoint தெளிவாக இருந்தாலும் cache_creation_input_tokens பூஜ்ஜியத்திலேயே (0) இருப்பதை நீங்கள் காணலாம்.

பயன்பாடு இல்லாத நினைவகத்தை நீக்குதல்

ஒவ்வொரு முறையும் நினைவகத்தில் உள்ள வரிகள் tokens-ஐ செலவிடுகின்றன. எனவே, ஒரு வரி சமீபத்தில் ஏதேனும் ஒரு பதிலில் மாற்றத்தை ஏற்படுத்தியதா என்பதைச் சரிபார்க்க வேண்டும். Claude Code இதற்கான வரம்புகளைத் தெளிவாக வரையறுக்கிறது. CLAUDE.md கோப்பை 200 வரிகளுக்குள் வைத்திருப்பது சிறந்தது; ஏனெனில் நீண்ட கோப்புகள் அதிக context-ஐ எடுத்துக்கொள்வதோடு, Claude-ன் துல்லியமான செயல்பாட்டையும் குறைக்கின்றன. MEMORY.md தொடக்கத்தின்போது முதல் 200 வரிகள் அல்லது 25KB வரை மட்டுமே எடுத்துக்கொள்ளப்படும். அந்த வரம்பிற்கு மேல் உள்ளவை அடுத்த அமர்வின்போது நீக்கப்படும் என்பதால், தேவையற்ற பெரிய index-ஐ வைத்திருப்பது tokens-ஐ வீணாக்குவதோடு எந்தப் பயனும் தராது.

கோப்பைச் சிறியதாக வைத்திருக்க இரண்டு பழக்கங்கள் அவசியம். விவரங்களை index-லிருந்து நீக்கி, தனித்தனி தலைப்பு கோப்புகளில் (topic files) சேமிக்கவும். இவற்றை Claude தேவைப்படும்போது மட்டும் வாசிக்கும். பணிப்பாய்வு வழிமுறைகளை (workflow instructions) CLAUDE.md-லிருந்து நீக்கி, skills-க்கு மாற்றவும்; இவை தேவைப்படும்போது மட்டுமே load ஆகும். ஏற்கனவே frontmatter கொண்ட நினைவகக் கோப்புகளில், Claude Code பதிப்பு 2.1.214 அல்லது அதற்கு மேற்பட்டவற்றில், modified புலத்தில் ISO 8601 timestamp மூலம் எழுதும் நேரம் பதிவு செய்யப்படும். காலாவதியான தகவல்களைக் கண்டறிய இந்த timestamp மிக வேகமான வழியாகும். பழைய agent நினைவகத்தை நீக்குதல் பகுதியில் இதற்கான ஆய்வு முறைகள் விரிவாக விளக்கப்பட்டுள்ளன.

அனைத்தையும் context-ல் ஏற்றுவதை விட retrieval சிறந்தது எப்போது

Memory tool என்பது just-in-time retrieval-ஐ ஆதரிக்கவே உருவாக்கப்பட்டது. அனைத்தையும் ஆரம்பத்திலேயே ஏற்றுவதற்குப் பதிலாக, agent தான் கற்றுக்கொண்டவற்றைப் பதிவு செய்து கொள்கிறது; ஒரு பணிக்குத் தேவைப்படும்போது மட்டுமே கோப்பை மீண்டும் வாசிக்கிறது. இது கணக்கீட்டை மாற்றுகிறது, ஏனெனில் ஒரு கோப்பை வாசிப்பதற்கான tokens ஒருமுறை மட்டுமே செலவாகும், அதன் பிறகு அது cached prefix-ல் இருக்கும். ஆனால், நிரந்தரமாக ஏற்றப்பட்ட ஒரு தொகுதி ஒவ்வொரு turn-இலும் செலவை ஏற்படுத்தும்.

மேலே உள்ள இரண்டு வரைபடங்களிலிருந்து ஒரு எளிய விதியைப் பெறலாம். ஒவ்வொரு turn-இலும் பயன்படுத்தப்படும் உரையை stable cached prefix-ல் வைத்திருக்க வேண்டும். இருபது turn-களில் ஒருமுறை மட்டும் பயன்படுத்தப்படும் உரையை view call-க்குப் பின்னால் வைத்திருக்க வேண்டும். இந்த break-even புள்ளி Anthropic-ன் கட்டணத்தைப் பொறுத்ததல்ல, உங்கள் replay எண்ணிக்கையைப் பொறுத்தது.

API-ல், உரையாடலைத் தானாகவே சுருக்குமாறு platform-ஐ நீங்கள் அனுமதிக்கலாம். நீங்கள் நிர்ணயிக்கும் வரம்பைத் தாண்டும்போது, பழைய tool முடிவுகளை context editing நீக்கிவிடும்.

{
  "edits": [
    {
      "type": "clear_tool_uses_20250919",
      "trigger": {"type": "input_tokens", "value": 30000},
      "keep": {"type": "tool_uses", "value": 3},
      "clear_at_least": {"type": "input_tokens", "value": 5000}
    }
  ]
}

இயல்புநிலை அமைப்புகள் 100,000 input tokens மற்றும் 3 tool பயன்பாடுகளைத் தக்கவைக்கும் வகையில் உள்ளன. இதைச் செயல்படுத்தும் முன் caching உடனான தொடர்பைப் புரிந்துகொள்ளுங்கள்: உள்ளடக்கத்தை நீக்கும்போது, அந்த இடத்தில் cached prefix செல்லாததாகிவிடும், எனவே அடுத்த கோரிக்கையின்போது நீங்கள் cache write கட்டணத்தைச் செலுத்த வேண்டியிருக்கும். இதற்காகத்தான் clear_at_least உள்ளது. சேமிக்கப்படும் அளவு, write கட்டணத்தை ஈடுசெய்யும் அளவுக்குப் பெரியதாக இருக்கும் வரை இது நீக்குவதைத் தள்ளிப்போடும். context_management-ன் கீழ் என்ன நடந்தது என்பதைப் பதில் துல்லியமாகத் தெரிவிக்கும், அதனுடன் cleared_tool_uses மற்றும் cleared_input_tokens ஆகியவையும் இருக்கும், எனவே இந்த வர்த்தகம் கோட்பாட்டு ரீதியாக இல்லாமல் அளவிடக்கூடியதாக இருக்கும். Claude Code-ல் context window-ஐ நிர்வகித்தல் இதே கருத்தை ஒரு coding session-க்கு எவ்வாறு பயன்படுத்துவது என்பதைக் காட்டுகிறது.

எந்தெந்த அம்சங்களுக்குத் தனித்தனியாகக் கட்டணம் வசூலிக்கப்படுகிறது

Memory-க்கு என்று தனியாகக் கட்டணம் ஏதுமில்லை, ஆனால் சில அம்சங்களுக்குக் கட்டணம் உண்டு. அவற்றை அறிந்துகொள்வது அவசியம். இவை ஆகஸ்ட் 2026 நிலவரப்படி வெளியிடப்பட்ட Claude API கட்டணங்கள். சில செயல்பாடுகளுக்குக் கட்டணம் இல்லை, ஆனால் Claude API-ல் இலவச அடுக்கு (free tier) கிடையாது. பதிவு செய்யும்போது வழங்கப்படும் சிறிய அளவிலான கிரெடிட் மட்டுமே உண்டு, எனவே உங்கள் முதல் கோரிக்கையிலிருந்தே அனைத்துச் செயல்பாடுகளுக்கும் கட்டணம் வசூலிக்கப்படும்.

• Web search: 1,000 தேடல்களுக்கு $10, அத்துடன் தேடல் முடிவுகள் context-ல் சேர்க்கப்படும்போது அதற்கான சாதாரண token கட்டணம்.
• Code execution: ஒவ்வொரு நிறுவனத்திற்கும் மாதம் 1,550 மணிநேரம் இலவசம், அதன் பிறகு ஒரு container-க்கு ஒரு மணிநேரத்திற்கு $0.05. Web search அல்லது web fetch-உடன் இதைப் பயன்படுத்தும்போது கட்டணம் இல்லை.
• Claude Managed Agents: வழக்கமான token கட்டணத்துடன், session runtime-க்கு ஒரு session-மணிநேரத்திற்கு $0.08.
• Web fetch: கூடுதல் கட்டணம் இல்லை, பெறப்பட்ட உள்ளடக்கத்திற்கான token கட்டணம் மட்டுமே உண்டு.

Memory-க்கு மேற்கூறியவற்றில் எந்தக் கட்டணமும் இல்லை. இது உங்கள் input token எண்ணிக்கையில் இடம்பெறுகிறது; அங்கேயே நீங்கள் இதைக் கணக்கிடலாம், மேலும் pruning மற்றும் caching மூலம் இதைக் குறைக்கலாம். ஒரு virtual private server (VPS)-ல் கவனிக்கப்படாமல் இயங்கும் agent-ஐ நீங்கள் நிர்வகிக்கிறீர்கள் என்றால், VPS-ல் உள்ள AI agent-க்கான செலவுக் கட்டுப்பாடுகளை முதலில் அமைக்க வேண்டும். ஏனெனில், pruning செய்யப்படாத, தொடர்ந்து வளர்ந்து வரும் memory கோப்பைக் கொண்ட ஒரு agent, எந்தவித அறிவிப்பும் இன்றி ஒவ்வொரு வாரமும் அதிகச் செலவை ஏற்படுத்தும்.

FAQ

Claude-ன் memory வசதிகளுக்குத் தனி கட்டணம் உள்ளதா?

இல்லை. Anthropic-ன் விலைப்பட்டியலில் ஒரு மில்லியன் input tokens, ஒரு மில்லியன் output tokens மற்றும் prompt caching மடங்குகளுக்கான கட்டணங்கள் மட்டுமே உள்ளன; memory-க்கு என்று தனியாகக் கட்டணம் இல்லை. Claude API-ல் memory tool என்பது client-side-ல் இயங்குகிறது, எனவே கோப்புகள் நீங்கள் ஏற்கனவே கட்டணம் செலுத்தும் storage-லேயே சேமிக்கப்படுகின்றன. Memory வசதியால் சேர்வது input tokens மட்டுமே; இவை ஒவ்வொரு முறையும் அந்தத் தகவலை அனுப்பும்போது, அந்த model-ன் வழக்கமான input கட்டணத்தில் கணக்கிடப்படும்.

Memory-ஐ அணைத்தால் Claude-ன் பயன்பாட்டுக் கட்டணம் குறையுமா?

இது ஒவ்வொரு request-ன் token எண்ணிக்கையைக் குறைக்கும், இதனால் ஒவ்வொரு request-ன் கட்டணமும் குறையும். இது ஒட்டுமொத்தமாகச் சேமிப்பைத் தருமா என்பது அதன் பிறகு நடக்கும் செயல்களைப் பொறுத்தது. Memory-ல் இருந்த தகவல்களை மீண்டும் பெற Claude மூன்று கோப்புகளைப் படித்து, உங்களிடம் இரண்டு கேள்விகளைக் கேட்க வேண்டியிருந்தால், அந்தத் tokens-க்கான கட்டணம் memory-க்கான கட்டணத்தை விட அதிகமாக இருக்கும். ஊகிப்பதை விட அளவிடுவது சிறந்தது: auto memory ஆன் செய்யப்பட்ட நிலையிலும், CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 மூலம் தொடங்கப்பட்ட நிலையிலும் /context-ஐ இயக்கி, ஒரே பணியைச் செய்ய செலவான மொத்த tokens-ஐ ஒப்பிட்டுப் பாருங்கள்.

எதையும் மாற்றாதபோதும் எனது பயன்பாடு ஏன் அதிகரித்தது?

இடைவெளிக்குப் பிறகு cache miss ஏற்படுவதுதான் இதற்கு மிக முக்கியமான காரணம். Cache பதிவுகள் இயல்பாக 5 நிமிடங்கள் அல்லது extended அமைப்பில் ஒரு மணி நேரம் வரை இருக்கும். எனவே, ஒரு இடைவெளிக்குப் பிறகு வரும் முதல் request, உங்கள் முழு prefix-ஐயும் அடிப்படை input கட்டணத்தில் மீண்டும் process செய்து, மீண்டும் எழுதும். இரண்டாவது பொதுவான காரணம் prefix மாற்றம்: ஒரு tool definition-ஐ மாற்றினால் முழு cache-ம் செல்லாததாகிவிடும், system prompt-ஐ மாற்றினால் system மற்றும் message cache செல்லாததாகிவிடும். ஒரு subscription திட்டத்தில், சமீபத்திய பயன்பாட்டில் 10 சதவீதம் அல்லது அதற்கு மேல் இருந்தால், /usage விவரங்கள் அந்தச் செயல்பாட்டைக் குறிப்பிடும்.

Memory-ஐ system prompt-ல் வைக்க வேண்டுமா அல்லது tool call-க்குப் பின்னால் வைக்க வேண்டுமா?

கிட்டத்தட்ட ஒவ்வொரு முறையும் தேவைப்படும் தகவல்களை system prompt-ல் வையுங்கள், ஏனெனில் அவை cached prefix-ல் தங்கி cache read கட்டணத்தில் செலவாகும். சில பணிகளுக்கு மட்டும் தேவைப்படும் தகவல்களை view call-க்குப் பின்னால் வையுங்கள், ஏனெனில் ஒருமுறை படிக்கப்படும் கோப்பு அதன் tokens-க்கான கட்டணத்தை ஒருமுறை மட்டுமே வசூலிக்கும், ஒவ்வொரு முறையும் அல்ல. இதற்கான முடிவை எடுக்கும் எண் உங்கள் replay count ஆகும், usage object அந்த எண்ணை நேரடியாக வழங்குகிறது.

Memory வசதிகள் subscription பயன்பாட்டு வரம்புகளில் கணக்கிடப்படுமா?

ஆம், மறைமுகமாக. ஏனெனில் subscription வரம்புகள் ஒவ்வொரு request-ம் சுமந்து செல்லும் tokens-ஆல் நுகரப்படுகின்றன. தானியங்கி context மேலாண்மையைத் தூண்டும் நீண்ட உரையாடல்கள் உங்கள் பயன்பாட்டு வரம்பை அதிகம் நுகரும் என்று Anthropic-ன் உதவி ஆவணங்கள் தெரிவிக்கின்றன. Memory ஒவ்வொரு request-ஐயும் சற்று நீளமாக்குகிறது, மேலும் நீண்ட உரையாடல்களில் அந்த நீளம் ஒவ்வொரு முறையும் மீண்டும் அனுப்பப்படுகிறது. Claude-ன் பயன்பாட்டு வரம்புகள் உண்மையில் எவ்வாறு செயல்படுகின்றன என்பது எப்போது பயன்பாடு மீட்டமைக்கப்படும் என்பதை விளக்குகிறது.