SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor

क्या Claude के memory फीचर्स के लिए अलग से पैसे लगते हैं?

Claude के memory फीचर्स की कोई अलग कीमत नहीं है। याद रखा गया टेक्स्ट इनपुट टोकन के रूप में दोबारा भेजा जाता है, जिसका शुल्क आपके usage और prompt caching पर निर्भर करता है।

क्या Claude के memory features के लिए अतिरिक्त शुल्क लगता है?

Claude के memory features का कोई अपना अलग मूल्य नहीं है। Anthropic की प्रकाशित दरें प्रति मिलियन input tokens और प्रति मिलियन output tokens के आधार पर हैं, जिसमें prompt caching के लिए अतिरिक्त दरें शामिल हैं, और इनमें से किसी को भी memory token नहीं कहा जाता है। Claude API (application programming interface) पर memory को स्टोर करने का कोई शुल्क नहीं लगता है, क्योंकि memory tool client-side पर होता है और फाइल आपके अपने स्टोरेज में रहती है।

Memory अभी भी आपके बिल को प्रभावित करती है, क्योंकि कोई याद रखा गया तथ्य केवल तभी उत्तर को बदलता है जब वह उस request के भीतर हो जिसे Claude पढ़ता है। याद रखने का अर्थ है उसे फिर से भेजना। वह टेक्स्ट input tokens के रूप में आता है और model की सामान्य input दर पर चार्ज किया जाता है, जब तक कि उसे cache न किया गया हो। दो संख्याएँ यह तय करती हैं कि कितना शुल्क लगेगा: प्रत्येक turn पर आप कितने tokens का याद रखा गया टेक्स्ट फिर से भेजते हैं, और क्या उस replayed टेक्स्ट को prompt cache से serve किया जा सकता है।

Pro, Max या Ultra subscription पर, आपके plan की निर्धारित सीमाओं के भीतर उपयोग के लिए प्रति token बिल नहीं लिया जाता है, इसलिए वहाँ memory आपके पैसों के बजाय आपके usage allowance का उपयोग करती है। यदि आप usage credits चालू करते हैं और सीमा पार कर जाते हैं, तो स्थिति बदल जाती है: आपकी requests pay-as-you-go पर स्विच हो जाती हैं, जिनका बिल standard API दरों पर बनता है और subscription से अलग चार्ज किया जाता है, इसलिए उस बिंदु से एक बड़ा memory block फिर से पैसे खर्च करवाता है। नीचे दी गई प्रक्रिया समान है। केवल इकाई बदलती है। वह allowance सीमित है, इसलिए यह जानना उपयोगी है कि Claude Pro की लागत क्या है और वह सीमा कहाँ है जहाँ इसके limits आपको रोकते हैं इससे पहले कि आप यह तय करें कि प्रत्येक turn में कितनी memory होनी चाहिए। Usage-based Claude Enterprise की स्थिति अलग है, क्योंकि यह seat price के ऊपर API दरों पर प्रत्येक token को मापता है, इसलिए एक बड़ा memory block allowance के बजाय फिर से पैसों में बदल जाता है। Seat-based Enterprise plans में एक usage allowance शामिल होता है, जिसमें सदस्यों द्वारा अपनी निर्धारित सीमा तक पहुँचने के बाद usage credits उपलब्ध होते हैं। ये legacy plans हैं जो contract renewal पर usage-based billing में बदल जाते हैं। यदि memory को कम करने से आपका उपयोग किसी छोटे plan की सीमा के भीतर आ जाता है, तो Max या Ultra से Pro पर जाना एक उचित कदम है। यदि आप जिस तुलना पर विचार कर रहे हैं वह Anthropic के अपने tiers के बजाय विभिन्न providers के बीच है, तो वर्तमान कीमतों पर ChatGPT के साथ Claude के plans की तुलना से शुरुआत करना सही रहेगा।

प्रत्येक Claude surface पर "memory" का क्या अर्थ है

तीन अलग-अलग उत्पाद इस शब्द का उपयोग करते हैं, और उन्हें आपस में मिला देने के कारण ही यह प्रश्न भ्रमित करने वाला लगता है।

Claude API पर memory tool। आप tools array में एक entry जोड़ते हैं और अपने स्वयं के कोड में file operations को लागू करते हैं।

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

अक्टूबर 2026 तक, इस tool को Messages API पर किसी beta header की आवश्यकता नहीं है और यह सभी Claude 4 और बाद के models पर काम करता है। यह client-side है: Claude view /memories जैसा कोई operation मांगता है, आपका handler आपके द्वारा नियंत्रित storage पर उसे चलाता है, और आप tool_result block में परिणाम लौटाते हैं। Anthropic कभी भी file को अपने पास नहीं रखता, इसलिए कोई storage शुल्क नहीं लगता। इसके बजाय आप round trip के लिए भुगतान करते हैं। tool definition हर request में भेजी जाती है, और वापस आने वाली file content उस बिंदु से बातचीत में बनी रहती है।

Anthropic उस overhead के निश्चित हिस्से को प्रकाशित करता है। Claude Opus 5 पर auto के tool choice के साथ, tool-use system prompt 286 tokens का है, जैसा कि अक्टूबर 2026 में प्रलेखित है। जब भी कोई tool मौजूद होता है, चाहे वह memory हो या कोई अन्य, इसका भुगतान प्रति request एक बार किया जाता है।

Claude Code। हर session की शुरुआत में दो mechanisms load होते हैं। CLAUDE.md files में आपके द्वारा लिखे गए निर्देश होते हैं। Auto memory उन notes को रखती है जिन्हें Claude स्वयं ~/.claude/projects/<project>/memory/ के अंतर्गत लिखता है। MEMORY.md की केवल पहली 200 lines या 25KB load की जाती है, जो भी सीमा पहले पूरी हो जाए, और इसके बगल की topic files को startup के बजाय मांग पर पढ़ा जाता है। startup पर load की गई हर चीज़ उस prefix का हिस्सा बन जाती है जिसे उस session की हर बाद की request वहन करती है। जब आप subscription का उपयोग करते हैं, तो memory शामिल usage allowance का उपयोग करती है, या उनके चालू होने पर सीमा के बाद usage credits का उपयोग करती है। Console या cloud providers के माध्यम से, Claude Code का बिल आपके संगठन को प्रति token भेजा जाता है, और memory context उसी billing method का पालन करता है। Claude Code sessions के बीच memory को कैसे याद रखता है file-दर-file loading order को कवर करता है।

Claude on the web। claude.ai पर, memory उन entries का एक समूह है जिन्हें Claude आपके chat करने के साथ लिखता और update करता है, जिसमें प्रत्येक project के लिए एक memory space होता है। Project memory का उपयोग डिफ़ॉल्ट रूप से आपके account memory के साथ किया जाता है; इसे पूरी तरह से अलग रखने के लिए project के page पर Use account memory को बंद करें। Settings > Your Claude > Manage next to Your memory में वह सूची होती है जो store की गई है, या पुराने layout में Settings > Memory, और memory toggle में Pause memory या Reset memory का विकल्प मिलता है। Memory Free plan पर भी उपलब्ध है। शामिल usage वाले paid plans पर, memory usage limits का उपयोग करती है, या उनके चालू होने पर सीमा पार करने के बाद usage credits का उपयोग करती है; usage-based Enterprise इसे API दरों पर बिल करता है।

याद रखा गया टेक्स्ट इनपुट टोकन के रूप में क्यों बिल किया जाता है

Messages API स्टेटलेस है। यह कॉल्स के बीच कुछ भी याद नहीं रखता है, इसलिए आपका क्लाइंट हर टर्न पर पूरी बातचीत भेजता है और मॉडल इसे दोबारा पढ़ता है। मेमोरी इस नियम का अपवाद नहीं है। यह उसी रिक्वेस्ट में टेक्स्ट का एक और ब्लॉक है।

यह विभाजन किसी भी रिस्पॉन्स पर usage ऑब्जेक्ट में दिखाई देता है।

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

input_tokens केवल उन टोकन्स को गिनता है जिन्हें न तो कैश से पढ़ा गया और न ही इसे बनाने के लिए उपयोग किया गया, जिसका व्यावहारिक अर्थ है अंतिम कैश ब्रेकपॉइंट के बाद के टोकन्स। रिक्वेस्ट के लिए कुल इनपुट cache_read_input_tokens प्लस cache_creation_input_tokens प्लस input_tokens है। Claude द्वारा तीन टर्न पहले खोली गई मेमोरी फाइल हर टर्न पर उस कुल योग के भीतर रहती है। यह cache_read_input_tokens के अंतर्गत आती है जब कैश किया गया प्रीफिक्स बना रहता है, cache_creation_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 में पेस्ट करके चलाएं और एक बार बिना उसके, और जो अंतर होगा वही वह लागत है जो हर turn पर आपको चुकानी पड़ती है। दो सावधानियां बरतें। यह गणना एक अनुमान है, और Anthropic द्वारा अपने system optimizations के लिए जोड़े गए अतिरिक्त tokens आपसे charge नहीं किए जाते। साथ ही, उसी model के विरुद्ध गणना करें जिसे आप वास्तव में चलाएंगे, क्योंकि Claude 4.7 और उसके बाद के versions एक नए tokenizer का उपयोग करते हैं जो समान text के लिए लगभग 30 प्रतिशत अधिक tokens उत्पन्न करता है।

Claude Code के भीतर यही प्रश्न बिना किसी curl के हल हो जाता है।

  • /context दिखाता है कि अभी क्या लोड है, जिसमें memory files भी शामिल हैं, ताकि आप कुछ भी टाइप करने से पहले window में उनका हिस्सा देख सकें।
  • /memory आपकी CLAUDE.md files को सूचीबद्ध करता है और auto memory folder को खोलता है।
  • /usage session totals को प्रिंट करता है, जिसमें 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 का आंकड़ा वह conversation है, जिसमें memory और सब कुछ शामिल है, जिसे हर turn पर cache rate पर फिर से भेजा जा रहा है। 1.2k input का आंकड़ा केवल वह uncached input है जिसका उपयोग cache entry बनाने के लिए नहीं किया गया था। Claude Code उस dollar राशि की गणना स्थानीय रूप से list prices से करता है, जब तक कि किसी administrator ने modelPricing managed setting के माध्यम से अनुबंधित दरें (contracted rates) निर्धारित न की हों, इसलिए यह एक अनुमान है और आपके invoice से भिन्न हो सकता है। Claude Console में Usage page ही आधिकारिक संख्या है।

फिर सीधे तुलना करें। दो नए sessions में एक ही शुरुआती प्रश्न पूछें, एक सामान्य और एक auto memory बंद करके।

CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 claude

प्रत्येक में /context चलाएं और memory files entry की तुलना करें। जो अंतर है, वही वह लागत है जो आपकी संचित memory हर session की शुरुआत में, किसी भी काम के होने से पहले, लेती है। Claude Code token usage कहाँ जाता है, इसका पूरा विवरण उन दो संख्याओं के साथ पढ़ना सार्थक है।

प्रति मिलियन टोकन मेमोरी को रीप्ले करने की लागत कितनी है?

Prompt caching ही वह कारण है जिससे एक ही मेमोरी ब्लॉक की लागत एक टर्न पर दूसरे टर्न की तुलना में दस गुना अधिक हो सकती है। Anthropic कैश दरों को प्रत्येक मॉडल की बेस इनपुट कीमत के गुणक (multiples) के रूप में प्रकाशित करता है, इसलिए डॉलर की कीमतें बदलने पर भी यह संबंध बना रहता है।

चार्टAnthropic's published prompt caching rates, as a multiple of base input price
इस चार्ट के पीछे का डेटा
[
  {
    "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
  }
]

अधिकांश मॉडलों पर एक कैश रीड की लागत बेस इनपुट कीमत का 0.1 गुना होती है। नवीनतम मॉडल सस्ते में रीड करते हैं: Claude Opus 5.5 और Claude Sonnet 5.5 पर बेस का 0.05 गुना, और Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5.2 तथा Claude Mythos 5.2 पर बेस का 0.025 गुना। 5 मिनट की लाइफटाइम वाली एंट्री लिखने की लागत बेस का 1.25 गुना है, और 1 घंटे की लाइफटाइम वाली लागत बेस का 2 गुना है। Anthropic का प्राइसिंग पेज ब्रेक-ईवन को स्पष्ट रूप से बताता है: 5 मिनट की अवधि पर एक कैश रीड के बाद, या 1 घंटे की अवधि पर दो कैश रीड के बाद कैशिंग फायदेमंद हो जाती है। स्वयं prompt caching गाइड कोई ब्रेक-ईवन आंकड़ा नहीं देती है, लेकिन सस्ती रीड दरें दोनों गणनाओं को अपरिवर्तित रखती हैं, क्योंकि राइट प्रीमियम ही वह लागत है जिसे रीड्स को वसूलना होता है। Prompt caching के लिए ब्रेक-ईवन पॉइंट वह गणना है जिसे आपको यह तय करने से पहले करना चाहिए कि मेमोरी कहाँ रखनी है।

ये गुणक रीप्ले काउंट को अंकगणित में बदल देते हैं। अगला ब्लॉक ऊपर प्रकाशित गुणकों का अंकगणित है, न कि किसी लाइव वर्कलोड का मापन। यह 100 टर्न के सेशन में एक मेमोरी ब्लॉक की तीन तरह से कीमत तय करता है, जिसे साधारण बेस इनपुट दर पर चार्ज किए गए टोकन की समतुल्य संख्या के रूप में व्यक्त किया गया है।

चार्टA memory block over 100 turns, expressed as base-rate 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"
  }
]

4,000 टोकन का एक मेमोरी ब्लॉक जो सभी 100 टर्न पर कैश मिस करता है, उसकी बिलिंग 400,000 बेस-रेट टोकन के समान होती है। वही ब्लॉक एक 5 मिनट के कैश राइट और 99 कैश रीड के पीछे 44,600 के समान बिल होता है। इसे इसके आकार के एक चौथाई तक कम करें और कैशिंग बनाए रखें, तो यह 11,150 के समान बिल होता है। उन 3 पंक्तियों में फीचर नहीं बदला। केवल रीप्ले व्यवहार बदला। पंक्तियाँ मानक 0.1x रीड का उपयोग करती हैं। Claude Opus 5.5 या Claude Sonnet 5.5 पर, जहाँ एक रीड की लागत 0.05x है, कैश किया गया 4,000 टोकन ब्लॉक घटकर 24,800 हो जाता है, और Claude Fable 5.1 पर यह 14,900 तक गिर जाता है। ये अभी भी टोकन काउंट हैं न कि पैसे, और टोकन काउंट को अपने मासिक बिल के आंकड़े में बदलना आपके मॉडल की प्रति-मिलियन दर से एक गुणा (multiplication) है। वह दर उस मॉडल द्वारा निर्धारित की जाती है जिसे आप चलाते हैं, इसलिए यदि एजेंट Claude Fable 5 पर चलेगा, तो इसकी प्रकाशित प्रति-मिलियन दरों और इसके उपयुक्त कार्यों से शुरुआत करें। यदि एजेंट पैसे बचाने के लिए छोटे मॉडल पर चलता है, तो Claude Haiku 5.5 उन प्रॉम्प्ट्स की कीमत कैसे तय करता है जो 100K टोकन से अधिक हो जाते हैं इसकी जाँच करें, इससे पहले कि आप इसकी मेमोरी को बढ़ने दें, क्योंकि रीप्ले की गई मेमोरी ही वह चीज है जो एक रिक्वेस्ट को उस सीमा से आगे ले जाती है। यदि प्रदाता केवल मॉडल के बजाय एक खुला प्रश्न है, तो Claude के API और ChatGPT पर समान कार्यों की लागत दिखाती है कि वह गुणा कहाँ अलग तरह से काम करता है, और एक मेमोरी-हैवी एजेंट इसके इनपुट पक्ष पर बहुत अधिक निर्भर करता है।

दूसरी पंक्ति यह मानती है कि बाद की 99 रिक्वेस्ट में से प्रत्येक तब आती है जब कैश एंट्री अभी भी जीवित है। वह धारणा ही वह जगह है जहाँ अधिकांश वास्तविक बिल गलत हो जाते हैं।

ब्रेक के बाद एक ही प्रश्न की लागत अधिक क्यों होती है?

कैश एंट्री का एक जीवनकाल (lifetime) होता है, और घड़ी उस अनुरोध (request) से शुरू होती है जो इसे लिखता या पढ़ता है। API का डिफ़ॉल्ट समय 5 मिनट है। 1 घंटे का विकल्प ऊपर दिखाए गए 2x राइट (write) लागत पर आता है। Claude Code में, एक घंटे का सब्सक्रिप्शन डिफ़ॉल्ट मुख्य बातचीत और शामिल उपयोग के भीतर चुने गए हेल्पर अनुरोधों पर लागू होता है; सब-एजेंट्स को 5 मिनट मिलते हैं जब तक कि आप लंबी अवधि न चुनें। जब आप उपयोग क्रेडिट (usage credits) का उपयोग कर रहे होते हैं, तो मुख्य बातचीत 5 मिनट पर आ जाती है; API की या क्लाउड प्रदाता पर यह डिफ़ॉल्ट रूप से 5 मिनट है। ENABLE_PROMPT_CACHING_1H=1 सेट करने से उपयोग क्रेडिट पर रहने के दौरान भी एक घंटे का जीवनकाल बना रहता है, और Claude Code v2.1.242 से, promptCacheTtl सेटिंग को 1h पर सेट करने से मुख्य बातचीत के लिए भी यही होता है। उसी संस्करण से, subagentPromptCacheTtl को 1h पर सेट करने से मुख्य बातचीत के बाहर के अनुरोधों के लिए लंबी अवधि का चयन होता है।

इसलिए, लंच के दौरान खुली छोड़ी गई किसी सत्र (session) में टाइप किया गया एक लाइन का प्रश्न महंगा होता है क्योंकि आपके दूर रहने के दौरान कैश एंट्री समाप्त हो गई थी। मेमोरी सहित पूरा प्रीफ़िक्स प्रोसेस किया जाता है और कैश-राइट दर पर फिर से कैश में लिखा जाता है। ब्रेक की अवधि ने वह कीमत तय की।

आप इस पर विश्वास करने के बजाय इसकी पुष्टि कर सकते हैं। Pro, Max, Ultra, Team या Enterprise प्लान पर, /usage ब्रेकडाउन हाल के उपयोग के 10 प्रतिशत या उससे अधिक के लिए जिम्मेदार किसी भी व्यवहार को चिह्नित करता है, और लंबा संदर्भ (long context) और कैश मिस (cache misses) दोनों वहां नाम से दिखाई देते हैं। Claude Code v2.1.251 से, /usage में सत्र ब्लॉक एक Prompt cache (main) लाइन भी जोड़ता है जो कैश से परोसे गए इनपुट का हिस्सा, मिस की संख्या और यह दिखाता है कि क्या कैश अभी वार्म (warm) है। API पर, शांत अवधि के बाद पहले अनुरोध पर cache_creation_input_tokens को वापस आपके प्रीफ़िक्स के पूर्ण आकार तक बढ़ते हुए देखें।

क्या चीज चुपचाप कैश को अमान्य (invalidate) कर देती है

कैश किया गया प्रीफिक्स इस क्रम में व्यवस्थित होता है: tools, फिर system, और अंत में messages। किसी एक स्तर पर किया गया बदलाव उस स्तर और उसके बाद की हर चीज को अमान्य कर देता है। किसी tool definition को एडिट करने से पूरा कैश हट जाता है। system prompt को एडिट करने से system और message कैश हट जाता है।

यह उन लोगों के लिए एक जाल है जो system prompt में memory रखते हैं और एजेंट के सीखने के साथ-साथ उसे फिर से लिखते हैं। प्रत्येक rewrite अपने पीछे की हर चीज की कैश की गई कॉपी को हटा देता है, इसलिए अगली रिक्वेस्ट में फिर से पूरा write करना पड़ता है। स्थिर (stable) सामग्री को शुरुआत में रखें और उसे स्थिर बनाए रखें, और परिवर्तनशील (volatile) सामग्री को message list के अंत में रहने दें जहाँ उसे अमान्य करना सस्ता पड़ता है।

एक दूसरी, अधिक शांत विफलता भी है। प्रत्येक मॉडल का एक न्यूनतम कैश करने योग्य प्रीफिक्स होता है: अक्टूबर 2026 में प्रकाशित आंकड़ों के अनुसार, Claude Opus 5 पर 512 tokens, Claude Sonnet 5 पर 1,024 tokens, और Claude Haiku 4.5 पर 4,096 tokens। Anthropic का डॉक्यूमेंटेशन स्पष्ट रूप से बताता है कि इससे कम होने पर क्या होता है: न्यूनतम सीमा से कम की रिक्वेस्ट बिना कैशिंग के प्रोसेस की जाती हैं, और कोई एरर नहीं दिया जाता है। इसलिए, यदि उस ब्रेकपॉइंट तक का पूरा प्रीफिक्स न्यूनतम सीमा से कम है, तो cache_control के साथ मार्क की गई मेमोरी फाइल चुपचाप कुछ भी नहीं करती है। इसका लक्षण यह है कि cache_creation_input_tokens 0 पर ही बना रहता है, जबकि आपके प्रॉम्प्ट में स्पष्ट रूप से एक ब्रेकपॉइंट मौजूद होता है।

ऐसी मेमोरी को हटाएँ जो अब उपयोगी नहीं है

मेमोरी की प्रत्येक लाइन हर टर्न पर टोकन की खपत करती है, इसलिए प्रत्येक लाइन के लिए यह सवाल महत्वपूर्ण है कि क्या उसने हाल ही में किसी उत्तर को प्रभावित किया है। Claude Code इन सीमाओं को स्पष्ट करता है। CLAUDE.md को 200 लाइनों से कम रखने का लक्ष्य रखें, क्योंकि लंबी फाइलें अधिक कॉन्टेक्स्ट का उपयोग करती हैं और Claude द्वारा उनके निर्देशों का पालन करने की विश्वसनीयता को कम करती हैं। MEMORY.md लोड होते समय पहली 200 लाइनों या 25KB तक सीमित रहता है, और उस सीमा के बाद का कोई भी डेटा अगले सेशन की शुरुआत में हटा दिया जाता है। इसलिए, एक बहुत बड़ी इंडेक्स फाइल अपने लोड किए गए हिस्से के लिए कॉन्टेक्स्ट का उपयोग करती है, जबकि बाकी हिस्सा अनपठित रह जाता है।

इसे छोटा रखने के लिए दो आदतें अपनाएं। विवरण को इंडेक्स से हटाकर टॉपिक फाइलों में ले जाएं, जिन्हें Claude स्टार्टअप के बजाय आवश्यकता पड़ने पर पढ़ता है। वर्कफ़्लो निर्देशों को CLAUDE.md से हटाकर स्किल्स में ले जाएं, जो केवल बुलाए जाने पर लोड होती हैं। उन मेमोरी फाइलों के लिए जो पहले से ही फ्रंटमैटर के साथ शुरू होती हैं, Claude Code वर्जन 2.1.214 या उसके बाद के वर्जन में modified फील्ड में ISO 8601 टाइमस्टैम्प के रूप में राइट टाइम रिकॉर्ड करता है। यह टाइमस्टैम्प किसी पुरानी हो चुकी जानकारी की पहचान करने का सबसे तेज़ तरीका है। पुराणी एजेंट मेमोरी को हटाना समीक्षा प्रक्रिया को अधिक गहराई से समझाता है।

जब सब कुछ context में लोड करने के बजाय retrieval बेहतर होता है

Memory tool का अस्तित्व just-in-time retrieval का समर्थन करने के लिए है। सब कुछ पहले से लोड करने के बजाय, agent जो सीखता है उसे record करता है और किसी file को केवल तब पढ़ता है जब किसी task को उसकी आवश्यकता होती है। यह गणना को बदल देता है, क्योंकि एक बार पढ़ी गई file अपनी सामग्री को आवश्यकता पड़ने पर जोड़ती है और फिर context से हटाए जाने तक बाद के requests में बनी रहती है, जबकि स्थायी रूप से लोड किया गया block हर एक turn पर लागत बढ़ाता है।

ऊपर दिए गए दो charts से एक सरल नियम निकलता है। वह text जिसका उपयोग लगभग हर turn में होता है, उसे stable cached prefix में होना चाहिए। वह text जिसका उपयोग बीस में से एक turn में होता है, उसे view call के पीछे होना चाहिए। break-even बिंदु आपके replay count के साथ बदलता है, न कि Anthropic द्वारा लिए जाने वाले किसी शुल्क के साथ।

API पर आप platform को conversation को trim करने की अनुमति भी दे सकते हैं। जब conversation आपके द्वारा निर्धारित threshold को पार कर लेती है, तो context editing पुराने tool results को हटा देती है। यह अभी beta में है, इसलिए जो requests इसका उपयोग करते हैं, उन्हें context-management-2025-06-27 beta header की आवश्यकता होती है।

{
  "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 का trigger और 3 tool uses को सुरक्षित रखना है। इसे enable करने से पहले caching के साथ interaction को पढ़ें: सामग्री को हटाने से clear किए जाने वाले बिंदु पर cached prefix अमान्य हो जाता है, इसलिए आपको अगले request पर cache write का शुल्क देना पड़ता है। clear_at_least इसी के लिए है। यह तब तक clear करने से रोकता है जब तक कि बचत write को उचित ठहराने के लिए पर्याप्त न हो जाए। response ठीक वही बताता है जो context_management के तहत हुआ है, जिसमें cleared_tool_uses और cleared_input_tokens शामिल हैं, इसलिए यह trade सैद्धांतिक होने के बजाय मापने योग्य है। Claude Code में context window को manage करना कोडिंग session में भी इसी विचार को लागू करता है।

किसका अपना अलग लाइन आइटम होता है

Memory का अपना कोई शुल्क नहीं है, लेकिन कुछ फीचर्स का शुल्क निश्चित रूप से होता है, और यह जानना उपयोगी है कि वे कौन से हैं। ये अक्टूबर 2026 तक प्रकाशित Claude API दरें हैं। कुछ ऑपरेशन्स पूरी तरह से निःशुल्क हैं, और Claude API test credits नए उपयोगकर्ताओं को इसे आज़माने में मदद करते हैं। Anthropic के pricing FAQ में केवल यह कहा गया है कि नए उपयोगकर्ताओं को API टेस्ट करने के लिए मुफ्त क्रेडिट मिलते हैं, और इसमें कोई राशि प्रकाशित नहीं की गई है। Max, Ultra और Team सब्सक्राइबर्स को भी मासिक API क्रेडिट मिलते हैं, जिन्हें Anthropic के दस्तावेज़ों में 31 अक्टूबर, 2026 को Max के लिए $100 और Ultra के लिए $200 के रूप में सूचीबद्ध किया गया था। Team प्लान पर क्रेडिट प्रति Standard सीट $20 और प्रति Premium सीट $100 हैं, जो pooled होते हैं और इनकी अधिकतम सीमा $500 प्रति माह है। Free, Pro और Enterprise प्लान इसके पात्र नहीं हैं, अप्रयुक्त क्रेडिट अगले महीने नहीं जुड़ते (roll over नहीं होते), और वे इंटरैक्टिव Claude Code या usage credits को कवर नहीं करते हैं। वे claude -p और Claude Agent SDK को कवर करते हैं, जब आप उन्हें सीधे लिंक किए गए Console संगठन से API key के साथ चलाते हैं। Claude Code GitHub Action, IDE एक्सटेंशन या डेस्कटॉप ऐप द्वारा शुरू किए गए रन, -p के साथ भी, इसमें शामिल नहीं हैं। वे क्रेडिट एक पेड प्लान का लाभ हैं, और नीचे दिए गए शुल्क उपलब्ध क्रेडिट या आपके पेड बैलेंस से काटे जाते हैं।

  • Web search: $10 प्रति 1,000 सर्च, साथ ही उस सभी कंटेंट की सामान्य टोकन लागत जिसे सर्च कॉन्टेक्स्ट में डालता है।
  • Code execution: प्रति संगठन हर महीने 1,550 मुफ्त घंटे, उसके बाद $0.05 प्रति घंटा प्रति कंटेनर। यह तब मुफ्त होता है जब उसी अनुरोध में टूल वर्जन 20260209 या उसके बाद के वर्जन पर web search या web fetch शामिल हो।
  • Claude Managed Agents: सेशन रनटाइम $0.08 प्रति सेशन-घंटा, सामान्य टोकन शुल्कों के अतिरिक्त।
  • Web fetch: कोई अतिरिक्त शुल्क नहीं, केवल फेच की गई सामग्री की टोकन लागत।

Memory इनमें से किसी भी लाइन में नहीं आती है। यह आपके इनपुट टोकन काउंट में दिखाई देती है, जहाँ से आप इसे सटीक रूप से माप सकते हैं, और जहाँ pruning और caching इसे कम कर सकते हैं। यदि आप किसी ऐसे एजेंट का बजट बना रहे हैं जो virtual private server (VPS) पर बिना निगरानी के चलता है, तो the cost controls for an AI agent on a VPS अगला कदम है जिसे लागू करना चाहिए, क्योंकि बढ़ती हुई memory फाइल और बिना pruning वाला एजेंट हर हफ्ते अधिक महंगा होता जाता है, बिना किसी रिपोर्टिंग के।

FAQ

क्या Claude के memory फीचर्स के लिए कोई अलग शुल्क है?

नहीं। Anthropic की मूल्य सूची में प्रति मिलियन इनपुट टोकन, प्रति मिलियन आउटपुट टोकन और प्रॉम्प्ट कैशिंग मल्टीपल के लिए दरें दी गई हैं, जिसमें memory के लिए कोई अलग लाइन नहीं है। Claude API पर memory टूल क्लाइंट-साइड होता है, इसलिए फाइलें उस स्टोरेज पर रहती हैं जिसके लिए आप पहले से भुगतान कर रहे हैं। memory जो जोड़ता है वह इनपुट टोकन हैं, जिनका बिल मॉडल की सामान्य इनपुट दर या लागू कैशिंग दर पर हर उस टर्न के लिए आता है जिसमें वे शामिल होते हैं।

क्या memory बंद करने से Claude सस्ता हो जाता है?

यह प्रत्येक अनुरोध (request) के टोकन काउंट को कम करता है, जिससे प्रत्येक अनुरोध की लागत कम हो जाती है। क्या इससे कुल मिलाकर पैसे बचते हैं, यह इस बात पर निर्भर करता है कि आगे क्या होता है। यदि Claude को तीन फाइलें दोबारा पढ़नी पड़ती हैं और memory में पहले से मौजूद जानकारी को फिर से बनाने के लिए आपसे दो सवाल पूछने पड़ते हैं, तो उन टोकन की लागत memory की लागत से अधिक होती है। अनुमान लगाने के बजाय इसे मापें: auto memory चालू करके एक सेशन में /context चलाएं और एक सेशन CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 के साथ शुरू करें, फिर एक ही कार्य पर खर्च किए गए कुल टोकन की तुलना करें।

जब मैंने कुछ भी नहीं बदला तो मेरा usage क्यों बढ़ गया?

सबसे आम कारण एक पॉज़ के बाद cache miss होना है। API पर cache एंट्री डिफ़ॉल्ट रूप से 5 मिनट तक रहती हैं; Claude Code मुख्य बातचीत और चुने गए हेल्पर्स के लिए सब्सक्रिप्शन के शामिल usage के भीतर डिफ़ॉल्ट रूप से एक घंटे का समय लेता है, और usage क्रेडिट, API की या क्लाउड प्रदाता पर पांच मिनट का समय लेता है। उस लाइफटाइम के समाप्त होने के बाद पहला अनुरोध आपके पूरे प्रीफ़िक्स को दोबारा प्रोसेस करता है और इसे cache-write दर पर फिर से लिखता है। दूसरा आम कारण प्रीफ़िक्स में बदलाव है: टूल की परिभाषा बदलने से पूरा cache अमान्य हो जाता है, और सिस्टम प्रॉम्प्ट बदलने से सिस्टम और मैसेज cache अमान्य हो जाते हैं। सब्सक्रिप्शन प्लान पर, /usage ब्रेकडाउन उस व्यवहार का नाम बताता है जब यह हालिया usage के 10 प्रतिशत या उससे अधिक के लिए जिम्मेदार होता है।

क्या memory को सिस्टम प्रॉम्प्ट में होना चाहिए या टूल कॉल के पीछे?

इसे सिस्टम प्रॉम्प्ट में तब रखें जब लगभग हर टर्न इसका उपयोग करता हो, क्योंकि तब यह cached प्रीफ़िक्स में रहता है और cache-read दर पर खर्च होता है। इसे view कॉल के पीछे तब रखें जब केवल कुछ कार्यों को इसकी आवश्यकता हो, क्योंकि यह फाइल के टोकन को जोड़ने में तब तक देरी करता है जब तक कि उनकी आवश्यकता न हो; परिणाम को बाद के टर्न पर तब तक दोबारा चलाया (replay) जाता है जब तक कि उसे कॉन्टेक्स्ट से हटाया न जाए। निर्णय लेने वाली संख्या आपकी रिप्ले काउंट है, और usage ऑब्जेक्ट प्रत्येक अनुरोध के लिए इनपुट, cache-write और cache-read टोकन दिखाता है।

क्या memory फीचर्स सब्सक्रिप्शन usage लिमिट में गिने जाते हैं?

हाँ, अप्रत्यक्ष रूप से, क्योंकि सब्सक्रिप्शन लिमिट उन टोकन द्वारा उपभोग की जाती है जो प्रत्येक अनुरोध में होते हैं। Anthropic का सहायता दस्तावेज़ बताता है कि लंबी बातचीत जो स्वचालित कॉन्टेक्स्ट प्रबंधन को ट्रिगर करती है, आपकी usage लिमिट का अधिक उपभोग करती है। memory प्रत्येक अनुरोध को थोड़ा लंबा बना देता है, और एक लंबा सेशन हर टर्न पर उस लंबाई को दोबारा चलाता है। Claude की usage लिमिट वास्तव में कैसे काम करती है इस विषय को कवर करता है कि क्या कब रीसेट होता है।

क्या यह लेख उपयोगी था?