संदर्भ प्रबंधन: इसे "भूलने" न दें और न ही टोकन जलाएं
📚 श्रृंखला नेविगेशन: पिछला लेख 18 · CLAUDE.md उपयोग मार्गदर्शिका आपको सिखाता है कि प्रोजेक्ट विनिर्देशों को उस "ऑनबोर्डिंग मैनुअल" में कैसे लिखा जाए। यह लेख अगले स्तर पर जाता है—यह मैनुअल, आपके संवादों (conversations) और पढ़ी गई फ़ाइलों के साथ, "संदर्भ विंडो" (context window) नामक कार्यक्षेत्र (workspace) में एक साथ रखा गया है। आज हम बात करेंगे कि इस कार्यक्षेत्र को अच्छी तरह से कैसे प्रबंधित किया जाए और इसे कैसे भरा न जाए।
जब आप पहली बार Claude Code का उपयोग करना शुरू करते हैं, तो एक मूर्खतापूर्ण काम करना बहुत आसान होता है।
एक अपरिचित मध्यम आकार के प्रोजेक्ट को संभालते हुए, यह सोचते हुए कि "इसे कुछ भी करने से पहले पूरी रिपॉजिटरी पढ़ने दें, ताकि यह समग्र तस्वीर को सबसे अच्छी तरह समझ सके", आपने कहा: "इस प्रोजेक्ट की सभी फ़ाइलें पढ़ें, और फिर मुझे आर्किटेक्चर बताएं।"
परिणाम क्या हुआ? इसने वास्तव में एक के बाद एक फ़ाइलें पढ़ीं, टर्मिनल तेज़ी से स्क्रॉल हुआ, और बीस से अधिक फ़ाइलें पढ़ने के बाद यह स्पष्ट रूप से धीमा और सुस्त हो गया। जब आपने इसे लॉगिन बग (login bug) को ठीक करने के लिए कहा, तो इसने उल्टा पूछा "आप जिस auth मॉड्यूल की बात कर रहे हैं वह किस फ़ाइल में है" — उस फ़ाइल को उसने दस मिनट पहले ही पढ़ा था। काम पूरा करने से पहले, यह "भूल" गया, और बहुत सारे टोकन (token) भी जला दिए।
इसे समझने के बाद मुझे पता चला: संदर्भ विंडो (context window) जितनी भरी हो, उतनी अच्छी नहीं होती, यह भर जाने पर और भी बेवकूफ हो जाती है। आज हम इस "कार्यक्षेत्र" (workspace) को विस्तार से समझेंगे—यह क्या है, भर जाने पर क्या होता है, इसे /compact (संपीड़ित) और /clear (साफ़) से कैसे प्रबंधित करें, उपयोग को वास्तविक समय में कैसे देखें, और स्रोत से टोकन (token) कैसे बचाएं।
इस लेख को पढ़ने के बाद, आप जानेंगे:
- एक सादृश्य जो आपको "संदर्भ विंडो" (context window) को पूरी तरह से समझने में मदद करेगा, और वास्तव में तब क्या होता है जब यह भर जाती है
/compact(संपीड़ित),/clear(साफ़), और एक नया सत्र शुरू करना—तीनों का उपयोग कब करना है, एक तालिका में स्पष्ट किया गया है- विशिष्ट कार्यों और अपेक्षित आउटपुट पर नज़र रखने के लिए
/contextऔर/usageका उपयोग करें - टोकन बचाने की 5 रोज़मर्रा की आदतें, जिनमें से प्रत्येक वास्तविक नुकसान से ली गई है
- समझें कि "ऑटो-कॉम्पैक्ट" (auto-compact) पृष्ठभूमि में क्या करता है, और अब इसके अचानक रुकावट से चौंकें नहीं
01 संदर्भ विंडो: Claude का "कार्यक्षेत्र" (Workspace) कितना बड़ा है
सबसे पहले इस मुख्य अवधारणा को स्थापित करते हैं।
संदर्भ विंडो (context window) — वह कुल क्षमता है जो Claude इस सत्र में एक साथ "देख" सकता है, जिसे टोकन (मॉडल की पाठ प्रसंस्करण की सबसे छोटी बिलिंग इकाई) द्वारा मापा जाता है।
इसमें केवल वे शब्द नहीं होते जो आप टाइप करते हैं, बल्कि पूरी तरह से बहुत सी चीज़ें होती हैं। आधिकारिक context-window.md इसे बहुत स्पष्ट रूप से तोड़ता है, और मैं इसे आपके लिए सरल शब्दों में अनुवाद करता हूँ:
| कार्यक्षेत्र में क्या रखा जाता है | यह कब अंदर आता है | यह कितना स्थान लेता है |
|---|---|---|
| सिस्टम प्रॉम्प्ट (Claude का व्यवहार विनिर्देश) | हर बार जब यह शुरू होता है, जिसे आप नहीं देख सकते | एक निश्चित ब्लॉक |
| आपका CLAUDE.md (वैश्विक + प्रोजेक्ट) | स्टार्टअप पर पूरी तरह से लोड किया गया | फ़ाइल के आकार पर निर्भर करता है |
| ऑटो-मेमोरी (auto memory) | स्टार्टअप पर लोड किया गया (एक ऊपरी सीमा है) | मध्यम |
| आपके द्वारा टाइप किया गया प्रत्येक वाक्य | जैसे-जैसे आप टाइप करते हैं वैसे-वैसे प्रवेश करता है | आमतौर पर बहुत छोटा |
| इसके द्वारा पढ़ी गई प्रत्येक फ़ाइल | हर बार जब यह एक पढ़ता है तो जोड़ा जाता है | सबसे बड़ा हिस्सा, सबसे तेज़ी से जलता है |
| आदेश आउटपुट, उपकरण परिणाम | प्रत्येक टूल कॉल के बाद जोड़ा गया | लॉग / बड़ी फ़ाइलें बहुत तेज़ी से |
क्या आपने देखा? आपको लगता है कि बातचीत मुख्य रूप से "वह है जो आप कहते हैं", लेकिन वास्तव में सबसे बड़ा हिस्सा वे फ़ाइलें और आदेश आउटपुट हैं जो वह पढ़ता है। पिछली बार इसे 20 से अधिक फ़ाइलें पढ़ने के लिए कहना कार्यक्षेत्र को एक ही बार में अन्य इंजीनियरिंग ड्राइंग से भरने के बराबर था, जिससे "काम" के लिए बहुत कम जगह बची।
तुलना: कार्यक्षेत्र का आकार। Claude को एक बढ़ई के रूप में सोचें जो एक कार्यक्षेत्र (workbench) पर काम कर रहा है। मेज का आकार निश्चित है, ड्राइंग, उपकरण, अर्द्ध-तैयार उत्पाद, और आपके द्वारा दिए गए स्टिकी नोट्स, सभी इस मेज पर फैले होने चाहिए। यदि मेज बड़ी है, तो वह एक ही समय में और अधिक चीजों का ध्यान रख सकता है; यदि मेज भर जाती है, तो उसे पिछली ड्राइंग को एक तरफ धकेलना होगा—और वह उस ड्राइंग की जानकारी "भूल" जाएगा।
यह मेज कितनी बड़ी है? यह आपके द्वारा उपयोग किए जा रहे मॉडल पर निर्भर करता है। अधिकांश मॉडल 200,000 टोकन के स्तर पर हैं, और कुछ मॉडल (जैसे [1m] पहचानकर्ता वाले) 1 मिलियन तक पहुंच सकते हैं। लेकिन संख्याओं को याद रखने की तुलना में एक वाक्य याद रखना अधिक उपयोगी है:
मेज कितनी भी बड़ी क्यों न हो, उसकी सीमाएँ होती हैं; जितनी अधिक यह भरी होगी, उतनी ही बेवकूफ होगी।
💡 एक वाक्य में सारांश: संदर्भ विंडो (context window) Claude का कार्यक्षेत्र है, और इसका अधिकांश भाग उसके द्वारा पढ़ी गई फ़ाइलों से भरा होता है, न कि आपके द्वारा कही गई बातों से; मेज की एक सीमा होती है, और जब यह भर जाती है, तो यह प्रारंभिक जानकारी को "गिराना" (भूलना) शुरू कर देती है।
02 जब कार्यक्षेत्र भर जाता है तो क्या होता है: यह धीमा, बेवकूफ और यहाँ तक कि "भूलने" वाला हो जाता है
यह इस लेख का याद रखने लायक सबसे महत्वपूर्ण निर्णय है: संदर्भ (context) जितना भरा हो उतना अच्छा नहीं है। जब यह एक निश्चित स्तर तक भर जाता है, तो Claude का प्रदर्शन स्पष्ट रूप से गिर जाएगा।
क्यों? मेज पर जितनी अधिक चीजें होंगी, मॉडल का "ध्यान" उतना ही अधिक फैलेगा, और पहले की अप्रासंगिक सामग्री वर्तमान कार्य में हस्तक्षेप करना शुरू कर देगी। उद्योग में इस घटना को "संदर्भ क्षय" (context rot) कहा जाता है।
आपको कैसे पता चलेगा कि यह "क्षय" हो गया है? मैंने कुछ प्रथम पंक्ति (first-line) के लक्षणों का सारांश दिया है, और यदि आप इनमें से किसी का भी अनुभव करते हैं, तो आपको सतर्क रहना चाहिए:
- यह असंगत (contradictory) होने लगता है, उस योजना को भूल जाता है जिस पर आप दोनों पहले ही सहमत हो चुके हैं
- उत्तर अस्पष्ट और सामान्य (general) हो जाते हैं, विवरण कम और कम होते जाते हैं, और यह सही बकवास बोलने लगता है
- उन चीजों को बार-बार पूछता है जिनका आपने पहले ही उत्तर दे दिया है (जैसे शुरुआत में "auth किस फ़ाइल में है")
- एक ही प्रश्न के लिए, यदि आप इसे दो बार से अधिक सही करते हैं और यह अभी भी वहीं अटका हुआ है
उदाहरण के लिए, डेटा माइग्रेशन स्क्रिप्ट लिखते समय, हमने एक घंटे से अधिक समय तक चैट की और बार-बार डिबग किया। बाद में, इसने वही गलत समाधान पेश किया जिसे हमने पहले भाग में एक साथ खारिज कर दिया था। ऐसा नहीं है कि इसकी क्षमता कम हो गई है, यह संदर्भ एक घंटे के डिबगिंग कचरे से प्रदूषित हो गया है।
तो जब मेज वास्तव में भर जाती है तो Claude क्या करेगा? यह स्वचालित रूप से संपीड़ित (auto-compact) हो जाएगा—भाग 05 इसे विस्तार से समझाता है। यहाँ आपको बस इतना जानने की ज़रूरत है: यह एक निष्क्रिय जीवन रक्षक क्रिया है, समय आप पर निर्भर नहीं है, और यह अचानक एक महत्वपूर्ण कार्य के बीच में आपको बाधित कर सकता है।
तो सही तरीका यह है: इसके स्वतः संपीड़ित (auto-compact) होने की प्रतीक्षा न करें, इसे स्वयं प्रबंधित करें। इसे कैसे प्रबंधित करें? आगे पढ़ें।
💡 एक वाक्य में सारांश: भरा हुआ संदर्भ "संदर्भ क्षय" (context rot) को ट्रिगर करता है—असंगति, सामान्यता (generalization), बार-बार पूछना; प्रदूषित मेज पर बार-बार सुधार करने के बजाय, इसे सक्रिय रूप से साफ़ करना बेहतर है।
03 दो झाड़ू: /compact संपीड़न (compress) vs /clear साफ़ (clear)
कार्यक्षेत्र को साफ़ करने के लिए, Claude Code आपको दो झाड़ू देता है, जिनके उद्देश्य बिल्कुल अलग हैं, उन्हें कभी भी भ्रमित न करें।
/compact: मेज पर चीजों को "पैक और संपीड़ित (compress)" करें, लेकिन उन्हें रखें
/compact (संपीड़ित) क्या करता है: संवाद इतिहास (conversation history) की वर्तमान लंबी स्ट्रिंग को एक संक्षिप्त सारांश में सारांशित करें, और फिर मूल शब्दशः (verbatim) रिकॉर्ड को सारांश से बदलें, और उसी कार्य पर काम करना जारी रखें।
तुलना: मेज पर फैले ड्राफ्ट पेपर के ढेर को एक पेज के मुख्य बिंदुओं में व्यवस्थित करना। आपने दो घंटे तक सहयोगियों के साथ चर्चा की है, और मेज रद्दी स्केच से भरी हुई है। /compact इस बात का सारांश दे रहा है कि "हमने अंततः ए तय किया, बी खारिज किया, और अगला चरण सी है" एक पेज में, डेस्कटॉप खाली कर रहा है, लेकिन निष्कर्ष अभी भी वहीं है।
महत्वपूर्ण रूप से, यह यह बताने के लिए निर्देशों का समर्थन करता है कि क्या रखना है:
/compact प्रमाणीकरण प्रवाह (authentication flow) के वास्तुशिल्प (architectural) निर्णयों और पुष्टि किए गए API प्रारूपों को बनाए रखें, और डिबगिंग के दौरान अमान्य प्रयासों को छोड़ देंआधिकारिक costs.md में दिया गया अंग्रेजी उदाहरण /compact Focus on code samples and API usage (कोड उदाहरणों और API उपयोग पर ध्यान दें) है, जिसका अर्थ समान है।
/compact का उपयोग कब करें: कार्य अभी समाप्त नहीं हुआ है, संदर्भ (context) लगभग भरा हुआ है, लेकिन पहले चर्चा की गई चीज़ों का बाद में उपयोग किया जाएगा। उदाहरण के लिए, एक सुविधा (feature) आधी पूरी हो गई है, प्रारंभिक वास्तुशिल्प (architectural) निर्णयों को नहीं छोड़ा जा सकता है, लेकिन बीच में बहुत सारे परीक्षण-और-त्रुटि आदेश आउटपुट (trial-and-error command outputs) फेंके जा सकते हैं।
/clear: सीधे साफ़ करें, शुरू से शुरू करें
/clear (साफ़) अधिक क्रूर है: संपूर्ण संवाद इतिहास (conversation history) को साफ़ करें, जो एक नया सत्र खोलने के बराबर है।
लेकिन डरो मत—/clear आपके CLAUDE.md और ऑटो-मेमोरी (auto-memory) को नहीं छुएगा, वे अभी भी नए सत्र में स्वचालित रूप से लोड होंगे। आप केवल "इस संवाद में जो चर्चा की गई थी" खो देते हैं, और प्रोजेक्ट विनिर्देश (specifications) और दीर्घकालिक मेमोरी (long-term memory) अभी भी वहीं हैं।
तुलना: एक बिल्कुल नए कार्य पर स्विच करना, और काम शुरू करने से पहले मेज को साफ़ करना बेहतर है। पिछला कार्य समाप्त हो गया है, और अगला कार्य इससे पूरी तरह असंबंधित है, इसलिए पिछली गड़बड़ी के हस्तक्षेप को रखने की तुलना में मेज को पूरी तरह से साफ़ करना बेहतर है।
आधिकारिक costs.md सीधे सुझाव देता है: असंबंधित कार्यों पर स्विच करते समय, नए सिरे से शुरू करने के लिए /clear का उपयोग करें, क्योंकि "पुराना संदर्भ (stale context) बाद के प्रत्येक संदेश पर टोकन बर्बाद करेगा"।
यहाँ स्थापित करने लायक एक लोहे का नियम है: यदि आप एक ही समस्या को दो बार सुधारते हैं और यह अभी भी गलत है, तो इस सत्र में समय बर्बाद न करें, सीधे /clear करें, इन दोनों बार सीखे गए सबक लें, और शुरू से पूछने के लिए एक अधिक सटीक प्रॉम्प्ट (prompt) फिर से लिखें। एक साफ़ मेज + एक बेहतर प्रॉम्प्ट लगभग हमेशा प्रदूषित संदर्भ में बहस जारी रखने से बेहतर होता है—यह अभ्यास से सबसे मूल्यवान अनुभव है।
💡 एक वाक्य में सारांश:
/compactका अर्थ है "पैक और संपीड़ित करें, इसे उपयोग करने के लिए रखें", और/clearका अर्थ है "पूरी तरह से साफ़ करें, कार्य बदलें और पुनः आरंभ करें"; यदि आप इसे दो बार सुधारते हैं और यह अभी भी गलत है, तो संकोच न करें,/clearकरें।
04 उपयोग की निगरानी करें: /context और /usage के साथ मेज पर कितनी जगह बची है देखें
अंतर्ज्ञान (intuition) से यह आंकना कि "क्या यह लगभग भर गया है" बहुत रहस्यमय है। Claude Code आपको वास्तविक संख्याएँ देखने के लिए दो आदेश (commands) देता है, इन दोनों नामों को भ्रमित न करें।
/context: देखें कि मेज किस चीज़ से भरी है
/context/context वर्तमान संदर्भ (context) के वास्तविक समय (real-time) के उपयोग की कल्पना करने के लिए एक रंगीन ग्रिड आरेख (color grid diagram) का उपयोग करेगा, और इसे श्रेणी के अनुसार सूचीबद्ध करेगा—सिस्टम प्रॉम्प्ट (system prompt) कितना लेता है, CLAUDE.md कितना लेता है, प्रत्येक MCP सेवा कितना लेती है, और संवाद इतिहास (conversation history) कितना लेता है, और यह अनुकूलन (optimization) सुझाव भी देगा। आधिकारिक context-window.md स्पष्ट करता है: यदि आप किसी भी समय अपना वास्तविक संदर्भ उपयोग (context usage) जानना चाहते हैं, तो /context चलाएं।
एक आदत जो विकसित करने लायक है: एक बड़ा काम शुरू करने से पहले नींव देखने के लिए /context का उपयोग करें। यदि आप पाते हैं कि एक निश्चित MCP सेवा एक बड़ा हिस्सा लेती है, या CLAUDE.md बेतुके रूप से फूला हुआ है, तो काम करने से पहले इसे साफ़ कर लें।
इसके साथ ही एक
/memoryकमांड है, जिसका उपयोग यह जांचने के लिए किया जाता है कि स्टार्टअप (startup) के दौरान कौन से CLAUDE.md और ऑटो-मेमोरी (auto-memory) फ़ाइलें वास्तव में लोड की गई थीं—जब आपको संदेह हो कि इसने कुछ "गलत याद" किया है तो जांच करने के लिए इसका उपयोग करें।
/usage: देखें कि इस सत्र में कितने टोकन / कितने पैसे खर्च हुए
/usage/usage के शीर्ष पर Session ब्लॉक वर्तमान सत्र के टोकन उपयोग के आंकड़े (token usage statistics) देता है, और स्थानीय अनुमानों के आधार पर इसे डॉलर में भी परिवर्तित करता है। आधिकारिक costs.md इसे मोटे तौर पर इस तरह दिखाता है:
Total cost: $0.55
Total duration (API): 6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes: 0 lines added, 0 lines removedअपेक्षित आउटपुट विवरण: Total cost इस सत्र की अनुमानित लागत (स्थानीय रूप से गणना की गई है, और वास्तविक बिल से भिन्न हो सकती है, आधिकारिक आंकड़े Claude Console के अधीन हैं); Total duration (API) वह समय है जो वास्तव में मॉडल को कॉल करने में लगता है; Total duration (wall) वह कुल समय है जब आपने इस सत्र को खुला रखा है।
⚠️ अनुस्मारक: Pro / Max ग्राहकों की सत्र लागत सदस्यता (subscription) में शामिल होती है, और इस डॉलर राशि का आपके बिल से कोई सीधा संबंध नहीं है, बस सापेक्ष परिमाण (relative magnitude) देखें। विशिष्ट पैकेजों और बिलिंग पर अध्याय 06 में चर्चा की गई है। यह लेख केवल "संदर्भ" (context) के दृष्टिकोण से टोकन (tokens) को देखता है।
हर बार मैन्युअल रूप से टाइप करना परेशान करने वाला लगता है? आधिकारिक तौर पर स्टेटस बार (statusline) में संदर्भ उपयोग (context usage) को लगातार प्रदर्शित करने का भी समर्थन किया गया है, ताकि यह हमेशा स्क्रीन पर लटकता रहे। विशिष्ट कॉन्फ़िगरेशन विधि के लिए आधिकारिक स्टेटसलाइन (statusline) दस्तावेज़ देखें, जिसे इस लेख में विस्तारित नहीं किया जाएगा।
💡 एक वाक्य में सारांश:
/contextदेखता है कि "मेज पर किस चीज़ का कब्ज़ा है", और/usageदेखता है कि "इस बार कितने टोकन / पैसे खर्च हुए"; बड़ा काम शुरू करने से पहले, नींव देखने के लिए/contextदेखें।
05 ऑटो-कॉम्पैक्ट (auto-compact): यह खुद को बचाएगा, लेकिन इस पर निर्भर न रहें
"ऑटो-कॉम्पैक्ट" का उल्लेख पहले कई बार किया जा चुका है, यह अनुभाग बताता है कि यह वास्तव में क्या है।
ऑटो-कॉम्पैक्ट (auto-compact) — यह Claude Code का अंतर्निहित (built-in) जीवन रक्षक तंत्र है: जब संदर्भ (context) विंडो सीमा (window limit) तक पहुंचने वाला होता है, तो यह स्वचालित रूप से संवाद इतिहास (conversation history) को एक सारांश में सारांशित कर देगा, जिससे आप सीधे दीवार से टकराने (crash) और त्रुटियों (errors) की रिपोर्ट करने से बचेंगे और काम जारी रखने के लिए जगह खाली करेंगे। आधिकारिक costs.md Claude Code के "लागत को स्वचालित रूप से अनुकूलित करने" (automatically optimizing costs) के दो साधनों में से एक के रूप में प्रॉम्प्ट कैशिंग (prompt caching) के साथ इसे सूचीबद्ध करता है।
तुलना: असेंबली लाइन पर स्वचालित अनलोडिंग (Automatic unloading on an assembly line)। कन्वेयर बेल्ट लगभग भरा हुआ है, और पूरी लाइन को फंसने से बचाने के लिए सिस्टम स्वचालित रूप से पुरानी सामग्री को इकट्ठा करता है और संकुचित (compact) करता है। आपको परवाह करने की ज़रूरत नहीं है, यह स्वचालित रूप से ट्रिगर होता है।
यह बहुत विचारशील लगता है, लेकिन मैं आपको सलाह देता हूं कि इस पर निर्भर न रहें, इसके दो कारण हैं:
सबसे पहले, इसका ट्रिगर समय आप पर निर्भर नहीं है। यह बहुत संभव है कि आप इसे एक महत्वपूर्ण कदम उठाने के लिए कह रहे हों, मेज अभी भरी हुई है, और यह संपीड़ित (compact) करने के लिए "स्नैप" (snap) करता है और रुक जाता है—पूरी लय बाधित (interrupted) हो जाती है।
दूसरा, ऑटो-कॉम्पैक्ट "बिना निर्देश" (without instructions) संपीड़न (compression) है। जिस क्षण यह ट्रिगर होता है, वह ठीक वही समय होता है जब संदर्भ (context) सबसे पूर्ण (full) होता है और मॉडल सबसे सुस्त होता है। इस समय, यह खुद तय करता है कि क्या फेंकना है और क्या रखना है, और यह बहुत संभव है कि यह आपके द्वारा महत्वपूर्ण मानी जाने वाली चीज़ को संपीड़ित (compact) कर देगा।
इसलिए, सही तरीका सक्रिय कार्रवाई करना (take active action) है: जब आपको लगता है कि संवाद लंबा हो रहा है और /context दिखाता है कि उपयोग अधिक है, पहले इसे स्वयं /compact करें, और इसे मुख्य बिंदुओं को रखने के लिए बताने के निर्देश लाएं। सक्रिय संपीड़न (Active compression) के दो फायदे हैं—आप तय करते हैं कि कब और क्या रखना है।
एक और अधिक चिंता मुक्त (worry-free) तरकीब है: अपनी संपीड़न प्राथमिकताओं (compression preferences) को सीधे CLAUDE.md में लिखें। आधिकारिक costs.md में लेखन विधि CLAUDE.md में एक पैराग्राफ जोड़ना है:
# Compact instructions (संपीड़न निर्देश)
When you are using compact, please focus on test output and code changes
(जब आप कॉम्पैक्ट का उपयोग कर रहे हों, तो कृपया परीक्षण आउटपुट और कोड परिवर्तनों पर ध्यान दें)इस तरह, हर बार जब यह संपीड़ित होता है (चाहे वह मैन्युअल हो या स्वचालित), तो यह आपके द्वारा निर्दिष्ट सामग्री को प्राथमिकता देगा, जो स्वचालित संपीड़न (auto-compact) पर बीमा (insurance) लगाने के बराबर है। उदाहरण के लिए, आमतौर पर उपयोग किए जाने वाले प्रोजेक्ट के CLAUDE.md में "संपीड़ित करते समय पुष्टि किए गए योजना निर्णयों और इंटरफ़ेस सम्मेलनों (interface conventions) को बनाए रखें" लिखना, हर बार इसे मैन्युअल रूप से बताने की आवश्यकता को बचाता है।
💡 एक वाक्य में सारांश: स्वचालित संपीड़न (Auto-compact) जीवन बचाने के लिए है, लेकिन यह आपको बाधित करेगा और महत्वपूर्ण जानकारी को संपीड़ित कर सकता है; इसके लिए प्रतीक्षा करने के बजाय, निर्देशों के साथ स्वयं सक्रिय रूप से
/compactकरना, या CLAUDE.md में अपनी प्रतिधारण प्राथमिकताओं (retention preferences) को हार्ड-कोड करना बेहतर है।
06 टोकन (Token) बचाने के 5 तरीके: मेज को स्रोत (source) से इतनी जल्दी भरने न दें
मेज को साफ करना एक उपाय है, इसे इतनी जल्दी भरने न देना सबसे अच्छी नीति है। निम्नलिखित पाँच तरकीबों का उपयोग हर रोज़ किया जा सकता है, और प्रत्येक चाल पैकेज (package) की कीमत की परवाह किए बिना "संदर्भ" (context) के परिप्रेक्ष्य से शुरू होती है।
पहली चाल: अभ्यास के लिए बड़े प्रोजेक्ट्स का उपयोग न करें। जैसा कि अध्याय 07 में बताया गया है—सीखने और प्रयोग करने के चरण में, तीन से पाँच फ़ाइलों के साथ एक टॉय प्रोजेक्ट बनाएँ। कम फ़ाइलें हैं, यह कम पढ़ता है, मेज साफ है, और आप स्पष्ट रूप से देख सकते हैं कि यह क्या करता है। "बीस से अधिक फ़ाइलों को पढ़ने और भूलने की बीमारी" वाले गड्ढे की जड़ यह है कि आपने शुरुआत में ही एक अपरिचित मध्यम आकार की रिपॉजिटरी ली।
दूसरी चाल: फ़ाइलों को सटीक रूप से इंगित करने के लिए @ का उपयोग करें, और इसे पूरी रिपॉजिटरी में खोजने न दें। यह कहने के बजाय कि "लॉगिन बग को ठीक करें" और इसे एक-एक करके फ़ाइलों को देखने दें, सीधे @src/api/auth.ts 401 समस्या को ठीक करें कहना बेहतर है। आधिकारिक costs.md इसे बहुत स्पष्ट रूप से बताता है: अस्पष्ट (vague) अनुरोध व्यापक स्कैनिंग (broad scanning) को ट्रिगर करते हैं, जबकि विशिष्ट (specific) अनुरोध इसे कम से कम फ़ाइल रीड के साथ कुशलतापूर्वक काम करने देते हैं। @ का अर्थ है इसकी नज़र को सीधे उस फ़ाइल पर लगाना।
तीसरी चाल: एक साथ बहुत सारी आवश्यकताएँ (requirements) न डालें। एक ही झटके में पाँच असंबंधित कार्य देने से, इसके द्वारा पढ़ी जाने वाली फ़ाइलें और उत्पन्न आउटपुट मेज को भर देंगे। इसे पाँच छोटे प्रश्नों में बाँटें, और प्रत्येक को एक बार में करें, और मेज हमेशा साफ़ रहेगी।
चौथी चाल: लंबे कार्यों को विभाजित करें, और एक काम पूरा होने पर साफ़ करें। एक बड़े फ़ंक्शन (feature) के लिए एक ही सत्र (session) पर शुरू से अंत तक निर्भर रहने की उम्मीद न करें। अपेक्षाकृत स्वतंत्र चरण (stage) पूरा करने के बाद, एक बार /compact करें; जब आप पूरी तरह से असंबंधित भाग पर स्विच करते हैं, तो पुनः आरंभ करने के लिए /clear का उपयोग करें।
पाँचवीं चाल: लंबे कार्यों को उप-एजेंट (subagent) पर छोड़ दें। परीक्षण (tests) चलाना, बड़ी संख्या में लॉग (logs) देखना, और दस्तावेज़ों की जाँच करना, जो भारी मात्रा में आउटपुट (output) उत्पन्न करते हैं, सब-एजेंट (subagent) पर छोड़ दिया जाना चाहिए—यह अपने स्वयं के स्वतंत्र कार्यक्षेत्र (workspace) पर काम करता है, और केवल मुख्य संवाद (main conversation) में निष्कर्ष सारांश (conclusion summary) वापस लाता है। आधिकारिक context-window.md उदाहरण में, सब-एजेंट ने 6100 टोकन फ़ाइल पढ़ी, और मुख्य संदर्भ (main context) में लौटने पर यह केवल 420 टोकन लेता है। सब-एजेंटों के लिए बाद में एक विशेष लेख है, यहाँ बस यह जान लें कि यह संदर्भ (context) को बचाने के लिए एक शक्तिशाली उपकरण है। (लिंक बाद में जोड़ा जाएगा)
"उपचार" (remedy) और "रोकथाम" (prevention) की तुलना करें, और आपको पता चल जाएगा कि आपको अपना प्रयास कहाँ लगाना चाहिए:
| क्रिया | प्रकृति | कब |
|---|---|---|
/compact | उपाय·संपीड़ित करें और रखें (Remedy·Compress and keep) | कार्य समाप्त नहीं हुआ है, संदर्भ (context) अधिक है, और पिछले पाठ (previous text) की अभी भी आवश्यकता है |
/clear | उपाय·साफ़ करें और पुनः आरंभ करें (Remedy·Clear and restart) | असंबंधित कार्य (unrelated work) पर स्विच करें, या बहुत अधिक प्रदूषण (pollution) |
सीधे नया सत्र खोलें (बाहर निकलें और फिर claude) | रोकथाम·पूरी तरह से साफ़ (Prevention·Completely clean) | एक बिल्कुल साफ़ मेज चाहते हैं, यहाँ तक कि इस मेमोरी ट्रेस (memory trace) को भी नहीं चाहते |
फ़ाइलों को सटीक रूप से इंगित करने के लिए @ | रोकथाम·कम फ़ाइलें पढ़ें (Prevention·Read fewer files) | आपको यह हर बार अनुरोध (request) करते समय करना चाहिए |
| अभ्यास के लिए टॉय प्रोजेक्ट | रोकथाम·स्रोत से कम (Prevention·Less from the source) | सीखना और प्रयोग (learning and experimentation) का चरण |
| सब-एजेंट लंबे कार्य करते हैं | रोकथाम·आउटपुट को अलग करें (Prevention·Isolate output) | परीक्षण चलाएँ / लॉग देखें / दस्तावेज़ जाँचे (Run tests / view logs / check docs) |
💡 एक वाक्य में सारांश: मेज को साफ़ करना एक उपाय (remedy) है, कम फ़ाइलें पढ़ना, कार्यों को विभाजित करना और उन्हें सब-एजेंटों (subagents) को सौंपना रोकथाम (prevention) है; विकसित करने के लिए सबसे महत्वपूर्ण मांसपेशी स्मृति (muscle memory) यह है कि—माँग करते समय फ़ाइलों को सटीक रूप से इंगित करने के लिए
@का उपयोग करें।
07 करके देखें: 3 चरणों में संदर्भ प्रबंधन (context management) से गुजरें
केवल देखने और अभ्यास न करने से आपको याद नहीं रहेगा। नीचे, हम आपको यह दिखाने के लिए एक न्यूनतम प्रक्रिया (minimal process) का उपयोग करेंगे कि संदर्भ (context) कैसे बढ़ता है और /compact इसे कैसे नीचे धकेलता है। किसी भी प्रोजेक्ट डायरेक्टरी में claude शुरू करें और उसका पालन करें।
पहला कदम: खेल शुरू करने से पहले नींव देखें
Claude शुरू करने के बाद, पहली चीज़ जो आपको टाइप करनी चाहिए वह है:
/contextअपेक्षा: टर्मिनल (terminal) वर्तमान संदर्भ (context) के वर्गीकृत उपयोग (categorized usage) को सूचीबद्ध करता है—आप देखेंगे कि सिस्टम प्रॉम्प्ट (system prompt), CLAUDE.md, आदि ने पहले ही एक हिस्सा ले लिया है (चैट करने से पहले उपयोग का होना सामान्य है), और नीचे कुल उपयोग (total usage) और अनुकूलन (optimization) सुझाव दिया गया है। इस प्रारंभिक संख्या (initial number) को लिख लें।
दूसरा कदम: जानबूझकर इसे कुछ सामग्री "फ़ीड" करें, और फिर परिवर्तन देखें
बस इसे कुछ फ़ाइलें पढ़ने दें और कुछ राउंड के लिए चैट करने दें, जैसे:
इस प्रोजेक्ट की मुख्य स्रोत फ़ाइलों (source files) को पढ़ें और मुझे समग्र संरचना (overall structure) बताएंइसके द्वारा पढ़ने और उत्तर देने के बाद, एक बार फिर टाइप करें:
/contextअपेक्षा: उपयोग (usage) में स्पष्ट रूप से वृद्धि हुई है, और संवाद इतिहास (conversation history) और फ़ाइलों (files) के स्तंभों (columns) में संख्याएँ बड़ी हो गई हैं। यह "कार्यक्षेत्र (workspace) के भरे जाने" की प्रक्रिया है, और आपने इसे अपनी आँखों से देखा है।
तीसरा कदम: इसे वापस धकेलने के लिए /compact का उपयोग करें
/compact इस प्रोजेक्ट की समग्र संरचना (overall structure) निष्कर्ष रखें, और एक-एक करके फ़ाइलों की मूल सामग्री को छोड़ देंअपेक्षा: टर्मिनल एक प्रॉम्प्ट (prompt) दिखाएगा जो "Conversation compacted" (संवाद संकुचित) के समान होगा। संपीड़न (compression) पृष्ठभूमि में चुपचाप किया जाता है, और सारांश (summary) को एक स्क्रीन पर ब्रश नहीं किया जाएगा। संपीड़ित करने (compacting) के बाद, /context पर फिर से एक नज़र डालें। संवाद इतिहास (conversation history) कॉलम का उपयोग कम हो जाना चाहिए था—यह अभी भी संरचना निष्कर्षों को याद रखता है, लेकिन फ़ाइलों के मूल बाइट्स (original bytes) को सारांश में संपीड़ित (compacted) कर दिया गया है।
तुलनात्मक सत्यापन (Comparative verification): संपीड़न (compression) से पहले और बाद में एक बार /context चलाएं। संवाद इतिहास (conversation history) में टोकन (token) की संख्या पहले उच्च और बाद में कम होनी चाहिए, जो इंगित करता है कि /compact ने प्रभावी रूप से काम किया है। यदि आप यह सत्यापित (verify) करना चाहते हैं कि यह "मेमोरी नहीं खोया" (amnesia) है, तो पूछें "अभी आपके द्वारा सारांशित की गई प्रोजेक्ट संरचना (project structure) क्या है", और इसे उत्तर देने में सक्षम होना चाहिए।
⚠️ एक विवरण: संपीड़न (compression) एक हानिकारक (lossy) क्रिया है। यह आपके द्वारा निर्दिष्ट मुख्य बिंदुओं और सामान्य रूपरेखा (general outline) को बरकरार रखता है, लेकिन शुरुआती टूल आउटपुट की शब्दशः सामग्री (verbatim content) को छोड़ दिया जाएगा। इसलिए, वास्तव में महत्वपूर्ण निष्कर्षों के लिए, उन्हें अध्याय 18 में वर्णित CLAUDE.md में डालने की आदत डालें—सीधे Claude को "CLAUDE.md में जोड़ने" के लिए कहें, या संवाद (conversation) में इसे दबाने की तुलना में इसे सुरक्षित रखने के लिए
/memoryका उपयोग करें।
💡 एक वाक्य में सारांश:
/context→ फ़ीड सामग्री (feed content) →/compact→ फिर/contextचलाएं, और आप अपनी आंखों से देखेंगे कि संदर्भ (context) कैसे बढ़ता है और संपीड़न (compression) इसे वापस कैसे धकेलता है; संवाद इतिहास (conversation history) में टोकन (tokens) की संख्या की तुलना करें और आपको पता चल जाएगा कि यह प्रभावी है या नहीं।
08 सारांश
इस लेख में, हमने "संदर्भ विंडो" (context window) कार्यक्षेत्र (workspace) को अंदर-बाहर छुआ है:
| आपने क्या सीखा | एक वाक्य में स्पष्ट |
|---|---|
| संदर्भ विंडो (context window) क्या है | Claude का कार्यक्षेत्र (workspace), इसका बड़ा हिस्सा इसके द्वारा पढ़ी गई फ़ाइलों का है, आपके शब्दों का नहीं |
| भर जाने पर क्या होगा | संदर्भ क्षय (context rot) को ट्रिगर करता है—धीमा हो जाता है, सामान्य (general) हो जाता है, असंगत (contradictory) हो जाता है, भूलने की बीमारी (amnesia) हो जाती है |
/compact | पैक करें और उपयोग के लिए संपीड़ित (compress) करें, बनाए रखने के लिए मुख्य बिंदुओं को निर्दिष्ट करने वाले निर्देशों के साथ |
/clear | काम स्विच करने के लिए पूरी तरह से साफ़ करें (clear), CLAUDE.md और मेमोरी को नहीं छूता है |
/context · /usage | एक देखता है कि "क्या लिया गया है", दूसरा देखता है कि "कितना खर्च हुआ है" |
| ऑटो-कॉम्पैक्ट (auto-compact) | जीवन-रक्षक तंत्र (Life-saving mechanism), लेकिन आपको बाधित करेगा, महत्वपूर्ण बिंदुओं को संपीड़ित कर सकता है, सक्रिय कार्रवाई (active action) बेहतर है |
| टोकन बचाएं (Save tokens) | टॉय प्रोजेक्ट (Toy projects), फ़ाइलों को इंगित करने के लिए @, बहुत अधिक न भरें, कार्यों को विभाजित करें, सब-एजेंटों (subagents) को सौंपें |
अब आपको सक्षम होना चाहिए: यह समझना कि संदर्भ विंडो (context window) में क्या है और क्यों Claude के भर जाने पर वह बेवकूफ हो जाता है; जब संपीड़ित (compress) करने का समय हो तो /compact का उपयोग करें, और पुनः आरंभ करने का समय आने पर /clear का उपयोग करें; वास्तविक समय (real time) में उपयोग की निगरानी के लिए /context और /usage का उपयोग करें; और मांग पूछने के क्षण से टोकन बचाने की कई आदतों का उपयोग करें, ताकि मेज पर हमेशा काम के लिए जगह हो।
अंत में, संदर्भ (context) के प्रबंधन का सार केवल एक वाक्य है: Claude के सीमित ध्यान (limited attention) को वास्तव में महत्वपूर्ण बातों पर खर्च करने के लिए बचाएं।
यह चित्र संदर्भ विंडो (context window) की तुलना एक कार्यक्षेत्र (workbench) से करता है: जब यह फ़ाइलों और संवादों (चित्र में लगभग 92% तक) से भरा होता है, तो चैट (chats) के ढेर को मुख्य बिंदुओं (रखने के लिए) के एक पृष्ठ (page) में संपीड़ित (compress) करने के लिए /compact पर भरोसा करें, या पूरे मेज को साफ़ करने के लिए /clear पर भरोसा करें (शुरू से शुरू करें)—पहला जानकारी रखता है, बाद वाला सफाई (cleanliness) के लिए है।
अगला लेख 20 · अनुमतियाँ कॉन्फ़िगरेशन (Permissions Configuration) —इस लेख में हम प्रबंधित करते हैं कि Claude "कितना याद रख सकता है", और अगले लेख में हम प्रबंधित करेंगे कि वह "कितना कर सकता है"। फ़ाइलें पढ़ने, कोड बदलने और आदेश (commands) चलाने के लिए उसे पहले आपसे क्या पूछना चाहिए, और उसे क्या जाने दिया जा सकता है? एक अनुमति नियम (permission rule) कैसे कॉन्फ़िगर करें जो सुरक्षित (safe) और उपयोग में आसान (easy to use) दोनों हो? आपके बारे में सोचने के लिए एक प्रश्न छोड़ें: क्या आप उसे आपकी सहमति के बिना सीधे git push चलाने देने के इच्छुक हैं?