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

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

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

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

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

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

மூன்று வெவ்வேறு தயாரிப்புகள் இந்த வார்த்தையைப் பகிர்ந்து கொள்கின்றன. அவற்றை குழப்பிக் கொள்வதே இந்த கேள்வி ஏன் குழப்பமாக உள்ளது என்பதற்கான முக்கிய காரணம்.

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

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

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

Anthropic அந்த மேல்நிலைச் செலவின் நிலையான பகுதியை வெளியிடுகிறது. 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 விருப்பங்களை வழங்குகிறது. இந்த தளம் சந்தா மூலம் கட்டணம் வசூலிக்கிறது, எனவே இங்குள்ள memory பயன்பாட்டு வரம்புகளைப் பயன்படுத்துகிறது.

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

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 திறந்த ஒரு memory கோப்பு, அன்றிலிருந்து ஒவ்வொரு சுற்றிலும் அந்த மொத்த எண்ணிக்கைக்குள் அமர்ந்திருக்கும். cached prefix இருக்கும் வரை அது cache_read_input_tokens-ன் கீழ் வரும், அது இல்லாதபோது input_tokens-ன் கீழ் வரும். ஒரே உரை, ஆனால் இரண்டு வெவ்வேறு விலைகள். உள்ளீட்டு மற்றும் வெளியீட்டு டோக்கன்கள் வெவ்வேறு விலைகளைக் கொண்டுள்ளன, மேலும் memory எப்போதும் உள்ளீட்டு பக்கத்தில் மட்டுமே அமையும்.

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

எந்தவொரு வலைப்பதிவிலும் (இந்தக் கட்டுரை உட்பட) கொடுக்கப்பட்டுள்ள புள்ளிவிவரங்களை அப்படியே எடுத்துக்கொள்ள வேண்டாம். உங்கள் சொந்த 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 அந்த டாலர் மதிப்பை list prices-ஐக் கொண்டு உள்ளூர் அளவில் கணக்கிடுகிறது, எனவே இது உங்கள் தள்ளுபடிகளைக் கணக்கில் கொள்ளாது மற்றும் உங்கள் invoice-லிருந்து மாறுபடலாம். Claude Console-ல் உள்ள Usage பக்கமே அதிகாரப்பூர்வமான எண்ணாகும்.

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

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 எண்ணிக்கையை எளிய கணிதமாக மாற்றுகின்றன. அடுத்த பகுதி, மேலே உள்ள வெளியிடப்பட்ட மடங்குகளைக் கொண்டு செய்யப்படும் கணிதமாகும்; இது எந்தவொரு நேரடி பணிச்சுமையின் (live 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 வரிசைகளிலும் அம்சம் (feature) மாறவில்லை. replay நடத்தை மட்டுமே மாறியது. இவை இன்னும் பணமாக அல்லாமல் token எண்ணிக்கையாகவே உள்ளன, மேலும் token எண்ணிக்கையை உங்கள் மாதாந்திர பில் தொகையாக மாற்றுவது என்பது உங்கள் model-ன் ஒரு-மில்லியன் விகிதத்தால் ஒருமுறை பெருக்கப்படும் செயலாகும். அந்த விகிதம் நீங்கள் இயக்கும் model-ஆல் தீர்மானிக்கப்படுகிறது, எனவே agent Claude Fable 5-ல் இயங்கினால், அதன் வெளியிடப்பட்ட ஒரு-மில்லியன் விகிதங்கள் மற்றும் அது பொருந்தும் பணிகள் என்பதிலிருந்து தொடங்கவும். model மட்டும் அல்லாமல், வழங்குநர் (provider) யார் என்பது இன்னும் முடிவாகவில்லை என்றால், Claude API மற்றும் ChatGPT-ல் ஒரே பணிகளுக்கான செலவு ஒப்பீடு அந்தப் பெருக்கல் பலன் எவ்வாறு மாறுபடுகிறது என்பதைக் காட்டும்; memory அதிகம் தேவைப்படும் agent-கள் input பக்கத்தில் அதிக செலவை ஏற்படுத்தும்.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{
  "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}
    }
  ]
}

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

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

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

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

Memory-க்கு மேலே உள்ள பட்டியலில் எந்தக் கட்டணமும் இல்லை. இது உங்கள் input token எண்ணிக்கையில் இடம்பெறுகிறது. அங்கேயே நீங்கள் இதைக் கணக்கிட முடியும், மேலும் pruning மற்றும் caching மூலம் இதைக் குறைக்க முடியும். ஒரு virtual private server (VPS)-ல் கவனிக்கப்படாத ஒரு agent-ஐ நீங்கள் இயக்குகிறீர்கள் என்றால், VPS-ல் உள்ள AI agent-க்கான செலவுக் கட்டுப்பாடுகளை அடுத்ததாகச் செயல்படுத்த வேண்டும். ஏனெனில், pruning செய்யப்படாத, தொடர்ந்து வளர்ந்து வரும் memory file-ஐக் கொண்ட ஒரு 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 எண்ணிக்கையைக் குறைக்கும், இதனால் ஒவ்வொரு கோரிக்கையின் செலவும் குறையும். இது ஒட்டுமொத்தமாகப் பணத்தைச் சேமிக்குமா என்பது அதன் பிறகு நடப்பதைப் பொறுத்தது. Memory-ல் இருந்த தகவலை மீண்டும் பெற Claude மூன்று கோப்புகளைப் படித்து உங்களிடம் இரண்டு கேள்விகளைக் கேட்க வேண்டியிருந்தால், அந்த tokens-ன் செலவு memory-ன் செலவை விட அதிகமாக இருக்கும். ஊகிப்பதற்குப் பதிலாக அளவிடுங்கள்: auto memory ஆன் செய்யப்பட்ட நிலையிலும், CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 கொண்டு தொடங்கப்பட்ட நிலையிலும் /context-ஐ இயக்கி, ஒரே பணியைச் செய்ய செலவான மொத்த tokens-ஐ ஒப்பிட்டுப் பாருங்கள்.

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

நீண்ட இடைவெளிக்குப் பிறகு ஏற்படும் cache miss தான் இதற்கு மிக முக்கியமான காரணம். Cache பதிவுகள் இயல்பாக 5 நிமிடங்கள் அல்லது extended அமைப்பில் ஒரு மணி நேரம் வரை இருக்கும். எனவே, இடைவெளிக்குப் பிறகு வரும் முதல் கோரிக்கை, உங்கள் முழு prefix-ஐயும் அடிப்படை input கட்டணத்தில் மீண்டும் செயலாக்கி, மீண்டும் எழுதும். இரண்டாவது பொதுவான காரணம் 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 எண்ணிக்கைதான் இதற்கான தீர்மானிக்கும் காரணி, usage object அந்த எண்ணிக்கையை நேரடியாக உங்களுக்கு வழங்கும்.

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

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