मेमोरी सिस्टम (memory): इसे क्रॉस-सत्रों में आपको याद रखने दें
📚 श्रृंखला नेविगेशन: पिछला लेख [24 Plugins] आपको सिखाता है कि कैसे बिखरी हुई कॉन्फ़िगरेशन के एक समूह को एक प्लगइन में पैकेज किया जाए जिसे एक क्लिक के साथ इंस्टॉल और रोका जा सकता है। यह लेख एक अधिक बुनियादी बात के बारे में बात करता है—Claude को क्रॉस-सत्रों में आपको याद कैसे रखने दें। यह केवल वह CLAUDE.md नहीं है जिसे आपने मैन्युअल रूप से लिखा है, बल्कि वह "निजी नोटबुक" भी है जो काम करते समय उसने खुद जमा की है। जब भी आप इसे सही करते हैं, तो यह चुपचाप इसे लिख लेता है, और अगली बार जब यह काम करना शुरू करता है तो इसे स्वचालित रूप से याद रखता है।
पहले एक जाल के बारे में बात करते हैं जिसमें नौसिखिए विशेष रूप से आसानी से कदम रखते हैं।
जब पहली बार "Claude को चीजें याद रखने में सक्षम बनाने" की सुविधा का पता चलता है, तो ऐसा महसूस करना आसान होता है जैसे आपको कोई खजाना मिल गया है, और आप सब कुछ इसमें भर देते हैं: आज एक पोर्ट नंबर डिबग किया और उसे भर दिया, एक अस्थायी चर का नाम बदला और उसे भर दिया, यहाँ तक कि एक बार की बकवास "इस बार 8080 के बजाय 8081 का उपयोग करें" को भी भर दिया। इसके पीछे का तर्क अक्सर "जितना अधिक आप याद रखेंगे, आप उतने ही होशियार होंगे" है।
नतीजा? दो हफ्ते बाद जब आप प्रोजेक्ट को फिर से खोलते हैं, तो वह अपना मुंह खोलता है और उस 8081 पोर्ट के बारे में बात करता है जिसे बहुत पहले छोड़ दिया गया था, साथ ही कुछ "प्राथमिकताएं" जो आप खुद भूल गए थे कि आपने उन्हें क्यों लिखा था। इसने बेकार चीजों से अपना दिमाग भर लिया है, और जो वास्तव में याद रखा जाना चाहिए वह डूब गया है।
तभी आपको समझ में आएगा: स्मृति जैसी चीज ऐसी नहीं है जिसे जितना अधिक भरा जाए, उतना ही बेहतर है, बल्कि यह "क्या याद रखा जाना चाहिए उसे सटीक रूप से याद रखना, और क्या नहीं याद रखा जाना चाहिए उसे न छूना" के बारे में है। गलत याद रखना बिल्कुल याद न रखने से ज्यादा बुरा है—यह आपको पुरानी जानकारी के साथ गंभीरता से गुमराह करेगा।
इससे पहले [18 CLAUDE.md उपयोग मार्गदर्शिका] में हमने विशेष रूप से इस बारे में बात की थी कि CLAUDE.md कैसे लिखना है, और [19 संदर्भ प्रबंधन] ने भी बार-बार उल्लेख किया है कि "स्वचालित मेमोरी संदर्भ पर कब्जा कर लेगी"। लेकिन इन दो टुकड़ों को एक पूर्ण "मेमोरी सिस्टम" में कैसे जोड़ा जाए, और वह नोटबुक जिसे Claude खुद लिखता है, वह कैसे काम करती है, यह कभी पूरी तरह से नहीं समझाया गया है। आज इसकी भरपाई करते हैं।
इस लेख को पढ़ने के बाद, आप प्राप्त करेंगे:
- Claude Code की यादें किन दो सेटों में विभाजित हैं: आपके द्वारा लिखा गया CLAUDE.md बनाम "स्वचालित मेमोरी" जिसे यह स्वयं लिखता है। यह समझने के लिए एक तालिका देखें कि कौन किसका प्रभारी है
- "ऑटो-मेमोरी" किस फ़ाइल में संग्रहीत है, इसे संदर्भ में कैसे लोड किया जाता है, और ऑडिट और संशोधित करने के लिए
/memoryका उपयोग कैसे करें - इसे एक प्रविष्टि कैसे याद रखने दें, याद रखने के बाद यह कहां गिरती है, और अगली बार यह स्वचालित रूप से कैसे प्रभावी होगी, आपको इसे चरण दर चरण चलाने के लिए ले जाती है
- एक "याद रखने योग्य बनाम याद न रखने योग्य" सूची जो आपको "सब कुछ भरने" के जाल से बचने में मदद करेगी
- क्या
#पुराने शॉर्टकट का अभी भी उपयोग किया जा सकता है? आधिकारिक वर्तमान सही तरीका क्या है
01 पहले अंतर करें: मेमोरी वास्तव में दो सेट है, एक सेट नहीं
आइए पहले निष्कर्ष देते हैं: Claude Code की "मेमोरी" समानांतर प्रणालियों के दो सेट हैं, एक आपके द्वारा लिखा गया है और दूसरा इसके द्वारा लिखा गया है, और प्रत्येक अपने स्वयं के व्यवसाय का प्रबंधन करता है। जब कई लोग "स्मृति" का उल्लेख करते हैं, तो वे केवल CLAUDE.md के बारे में सोचते हैं, जो वास्तव में केवल आधा है।
सादृश्य: मॉनिटर के किनारे पर चिपकाए गए स्टिकी नोट्स। आपकी डेस्क पर अक्सर दो तरह के कागज़ होते हैं। एक "कार्य नियम" है जिसे आप वास्तव में प्रिंट करते हैं और विभाजन पर पिन करते हैं—प्रोजेक्ट नियम, सबमिशन प्रक्रियाएं, जो बड़े करीने से लिखे गए हैं और जो भी आता है उसका पालन करेगा। यह CLAUDE.md है। दूसरा एक चिपचिपा नोट है जिसे आप लापरवाही से फाड़ देते हैं, "पिछली बार बग यह था कि कैश साफ़ नहीं किया गया था" लिखते हैं और इसे मॉनिटर के किनारे पर चिपका देते हैं, ताकि जब आप अगली बार इसे देखेंगे तो आपको याद आ जाएगा—इस तरह का छोटा नोट जो वह लापरवाही से रिकॉर्ड करता है, "ऑटो-मेमोरी (auto-memory)" है। आपकी आँखों के सामने दोनों तरह के कागज़ हैं, लेकिन एक "मेरे द्वारा बनाए गए नियम" हैं, और दूसरा "अनुभव जो मैंने आसानी से रिकॉर्ड किया है"।
आधिकारिक दस्तावेज़ इन दो सेटों के श्रम विभाजन को बहुत स्पष्ट रूप से समझाता है, और उन्हें एक तुलना तालिका में व्यवस्थित करता है—यह इस लेख में याद रखने वाली पहली तालिका है:
| आयाम | CLAUDE.md फ़ाइल | ऑटो-मेमोरी (auto-memory) |
|---|---|---|
| किसने लिखा | आप (मैन्युअल रूप से लिखें) | Claude (स्वयं लिखें) |
| क्या रखता है | निर्देश और नियम | अनुभव और पैटर्न जो इसने सीखे हैं |
| विशिष्ट सामग्री | प्रोग्रामिंग मानक, कार्यप्रवाह, परियोजना वास्तुकला | कमांड बनाएँ, डिबगिंग अंतर्दृष्टि, यह आपकी प्राथमिकताओं का पता लगाता है |
| कब लोड किया गया | प्रत्येक सत्र, पूर्ण लोड | प्रत्येक सत्र, लेकिन केवल पहली 200 पंक्तियाँ या 25KB लोड करता है |
| दायरा | उपयोगकर्ता / प्रोजेक्ट / स्थानीय स्तर | प्रत्येक git रिपॉजिटरी के लिए एक प्रति (सभी worktree द्वारा साझा) |
क्या आपने मुख्य अंतर देखा? CLAUDE.md "आप क्या चाहते हैं कि वह कैसे काम करे" है, और ऑटो-मेमोरी "उसने खुद जो पता लगाया है वह कैसे करना है" है। आप इसे सही करते हैं, "इस प्रोजेक्ट को परीक्षण चलाने के लिए पहले स्थानीय Redis शुरू करना होगा", और यह इसे अगली बार याद रखेगा—आपको इस आइटम को किसी भी फ़ाइल में मैन्युअल रूप से लिखने की आवश्यकता नहीं है, यह इसे स्वयं सहेजता है।
एक और आधिकारिक रूप से बार-बार जोर दिया गया है, और आपको पहले अनुभूति को पूरी तरह से समझना चाहिए:
Claude उन्हें संदर्भ के रूप में मानता है,强制 कॉन्फ़िगरेशन के रूप में नहीं। किसी कार्रवाई को रोकने के लिए, चाहे Claude कुछ भी तय करे, इसके बजाय PreToolUse hook का उपयोग करें।
इसका क्या मतलब है? मेमोरी (चाहे कोई भी सेट हो) केवल एक नरम संकेत है जो "प्रभावित करता है कि यह क्या करना चाहता है", यह "लॉक करने कि यह क्या कर सकता है" के लिए एक कठिन बाधा नहीं है। यह [20 अनुमति कॉन्फ़िगरेशन] में निष्कर्ष के समान है—यदि आप वास्तव में किसी ऑपरेशन को रोकना चाहते हैं, तो आपको अनुमति नियमों या हुक पर भरोसा करना होगा। मेमोरी में "पुश न करें" लिखना इसे रोक नहीं सकता है। मेमोरी "इसे आपको बेहतर समझने" के लिए ज़िम्मेदार है, "आपके लिए जाँच करने" के लिए नहीं।
💡 एक वाक्य का सारांश: मेमोरी को दो सेटों में बांटा गया है—CLAUDE.md आपके हस्तलिखित नियम हैं, और ऑटो-मेमोरी इसके स्वयं के नोट्स हैं; दोनों सेट केवल नरम संकेत हैं, और यदि आप वास्तव में संचालन को रोकना चाहते हैं, तो आपको अनुमतियों या हुक पर भरोसा करना होगा। इसे मेमोरी में लिखना पर्याप्त नहीं है।
यह चित्र साथ-साथ दो मेमोरी पथ खींचता है: बाईं ओर CLAUDE.md (प्रोजेक्ट नियम) है जिसे आपने हाथ से लिखा है और संदर्भ में पूरी तरह से लोड किया गया है; दाईं ओर ऑटो-मेमोरी (निजी नोटबुक) है जिसे Claude काम करते समय अपने आप MEMORY.md में रिकॉर्ड करता है और अगले सत्र में पहली 200 पंक्तियों को स्वचालित रूप से पढ़ता है। दोनों लाइनें अंततः "नए सत्र के लिए संदर्भ विंडो" में विलीन हो जाती हैं, ताकि यह काम करना शुरू करते ही "आपको याद रखे"।
02 मेमोरी सिस्टम में CLAUDE.md की स्थिति
CLAUDE.md [18] को कैसे लिखा जाए, इसके बारे में पहले ही विस्तार से बात की जा चुकी है, इसलिए मैं यहाँ केवल एक बात जोड़ दूँगा कि यह "मेमोरी सिस्टम" में क्या भूमिका निभाता है—यह वह स्थायी "कार्य नियम" है जिसे सभी को पढ़ना चाहिए।
सादृश्य: फिर से, मॉनिटर के बगल में दो प्रकार के कागज़ हैं, CLAUDE.md वह है जिसे पिन किया गया है। यह कोई स्टिकी नोट नहीं है जिसे लापरवाही से फाड़ दिया गया हो, यह एक औपचारिक नियम है जिसे आपने सावधानीपूर्वक प्रिंट किया है और पिन के साथ मजबूती से पिन किया है। इसलिए इसमें कई विशेषताएं हैं जो ऑटो-मेमोरी से पूरी तरह अलग हैं: आपके द्वारा लिखा गया, संस्करण नियंत्रण दर्ज करता है और पूरी टीम द्वारा साझा किया जाता है, प्रत्येक सत्र में पूरी तरह से लोड किया जाता है, और सामग्री "नियम" है "अनुभव" नहीं।
अधिकारियों ने लोडिंग क्रम के अनुसार (सबसे व्यापक से लेकर सबसे विशिष्ट तक) CLAUDE.md का स्पष्ट पदानुक्रम बनाया है:
| पदानुक्रम | स्थान | प्रभारी कौन है |
|---|---|---|
| होस्टिंग नीति स्तर | macOS: /Library/Application Support/ClaudeCode/CLAUDE.mdLinux/WSL: /etc/claude-code/CLAUDE.md | एंटरप्राइज़ IT समान रूप से जारी किया गया, व्यक्ति आमतौर पर शामिल नहीं होते हैं |
| उपयोगकर्ता स्तर | ~/.claude/CLAUDE.md | आपके सभी प्रोजेक्ट की व्यक्तिगत प्राथमिकताएँ |
| परियोजना स्तर | ./CLAUDE.md या ./.claude/CLAUDE.md | यह प्रोजेक्ट, पूरी टीम द्वारा साझा किया गया (git में) |
| स्थानीय स्तर | ./CLAUDE.local.md | यह प्रोजेक्ट, केवल आपके लिए (.gitignore में) |
ऑटो-मेमोरी से एक महत्वपूर्ण अंतर है, जिसे नौसिखियों को दृढ़ता से याद रखना चाहिए:
CLAUDE.md चाहे कितना भी लंबा हो, यह पूरी तरह से लोड हो जाता है, जबकि ऑटो-मेमोरी की ऊपरी सीमा होती है। आधिकारिक मूल शब्द—"CLAUDE.md फ़ाइल लंबाई की परवाह किए बिना पूरी तरह से लोड हो जाती है।" इसलिए [18] ने बार-बार आपको इसे 200 पंक्तियों के भीतर रखने की सलाह दी है: ऐसा इसलिए नहीं है कि इसे लोड नहीं किया जा सकता है, बल्कि जितना लंबा आप लिखते हैं, यह संदर्भ में उतनी ही अधिक जगह लेता है, और यह उतना ही खराब तरीके से इसका पालन करता है। इसके विपरीत, ऑटो-मेमोरी की एक कठिन ऊपरी सीमा होती है (जिसके बारे में हम अगले भाग में विस्तार से बात करेंगे), और जो हिस्सा उससे अधिक है वह बिल्कुल भी लोड नहीं होता है।
व्यवहार में श्रम का विभाजन बहुत स्पष्ट हो सकता है: "यह आपके द्वारा निर्धारित एक सख्त नियम है" CLAUDE.md में लिखा गया है, और "यह कुछ ऐसा है जो इसे खुद पता लगाने और जमा करने देता है" ऑटो-मेमोरी पर छोड़ दिया गया है। उदाहरण के लिए, "निर्भरताएँ केवल pnpm का उपयोग करती हैं" जैसे लौह नियमों को CLAUDE.md में मैन्युअल रूप से लिखा जाता है; जबकि "इस प्रोजेक्ट के परीक्षण को Redis शुरू करना चाहिए" कुछ ऐसा है जो यह स्वयं खोज सकता है, इसलिए इसे मैन्युअल रूप से लिखने की कोई आवश्यकता नहीं है, बस इसे एक बार ठीक करें और इसे स्वयं याद रखने दें।
💡 एक वाक्य का सारांश: CLAUDE.md मेमोरी सिस्टम में वह "पिन किया गया औपचारिक नियम" है—आप इसे लिखते हैं, टीम इसे साझा करती है, यह पूरी तरह से लोड है, और इसमें नियम हैं; इसकी स्थिति ऑटो-मेमोरी से पूरी तरह अलग है, जो "अनुभवों को आसानी से रिकॉर्ड करना" है।
03 ऑटो-मेमोरी: नोटबुक जो उसने खुद लिखी है
यहाँ मुख्य बिंदु आता है, जो [18] का मुख्य विषय भी है जिसे इस लेख के लिए छोड़ दिया गया था—ऑटो-मेमोरी (auto-memory), वह नोटबुक जिसे Claude काम करते समय अपने लिए रखता है।
ℹ️ ऑटो-मेमोरी के लिए Claude Code v2.1.59 या उच्चतर की आवश्यकता होती है, और यह डिफ़ॉल्ट रूप से चालू होता है। अपना संस्करण देखने के लिए
claude --versionटाइप करें; यदि यह बहुत पुराना है, तो इसे अपग्रेड करें (अपग्रेड विधि के लिए [02 इंस्टॉलेशन] देखें)।
सादृश्य: एक पुराना साथी जिसने लंबे समय तक काम किया है। एक साथी जिसने कुछ समय के लिए आपके साथ सहयोग किया है, आपको कुछ चीजें बार-बार समझाने की आवश्यकता नहीं है—वह उन्हें अपने दिमाग में याद रखेगा: "इस प्रोजेक्ट को npm build के बजाय make build चलाना चाहिए", "पिछली बार वह कभी-कभार आने वाला बग इसलिए था क्योंकि समय क्षेत्र सही ढंग से सेट नहीं किया गया था"। अगली बार जब वह इसी तरह की स्थिति का सामना करेगा, तो वह इसे खुद याद रखेगा। आपको कुछ भी समझाने की आवश्यकता नहीं है, वह काम करते-करते जमा हो जाएगा—ऑटो-मेमोरी Claude की इस तरह की "सक्रिय सीखने" की क्षमता है।
यह वास्तव में क्या याद रखता है? आधिकारिक सूची: बिल्ड कमांड, डिबगिंग इनसाइट, आर्किटेक्चरल नोट्स, कोड स्टाइल प्राथमिकताएं और वर्कफ़्लो आदतें। एक प्रमुख डिज़ाइन पर ध्यान दें—यह इसे हर सत्र में रिकॉर्ड नहीं करता है, बल्कि "भविष्य की बातचीत में जानकारी का उपयोग किया जाएगा या नहीं, इस आधार पर यह तय करता है कि क्या यह याद रखने योग्य है"। यह आमतौर पर एकमुश्त बकवास रिकॉर्ड नहीं करता है (यह "सब कुछ भरने" की बीमारी को ठीक करता है)।
तो यह वास्तव में इसे कैसे लिखता है? दो ट्रिगर विधियां:
पहली, आप इसे सीधे याद रखने के लिए कहते हैं। बातचीत में एक वाक्य कहें "भविष्य में इस प्रोजेक्ट के लिए pnpm का उपयोग करें, npm का नहीं" या "याद रखें कि API परीक्षण के लिए स्थानीय Redis शुरू करने की आवश्यकता है", और यह इस प्रविष्टि को ऑटो-मेमोरी में सहेज लेगा। आधिकारिक मूल पाठ:
जब आप Claude को कुछ याद रखने के लिए कहते हैं, जैसे "हमेशा pnpm का उपयोग करें, npm का नहीं" या "याद रखें कि API परीक्षण के लिए स्थानीय Redis इंस्टेंस की आवश्यकता होती है", तो Claude इसे ऑटो-मेमोरी में सहेजता है।
दूसरी, यह आपके सुधारों से खुद सीखता है। आपको स्पष्ट रूप से "याद रखें" कहने की आवश्यकता नहीं है, जब तक आप इसे एक बार सही करते हैं—उदाहरण के लिए, यदि यह npm test का उपयोग करता है और आप कहते हैं "यह प्रोजेक्ट pnpm test है"—यह न्याय करेगा कि यह प्रविष्टि भविष्य में उपयोगी होगी, और यह इसे स्वयं रिकॉर्ड करेगा। ऑटो-मेमोरी के बारे में यह सबसे अच्छी बात है: आप सामान्य रूप से काम करते हैं, सामान्य रूप से सही करते हैं, और यह शून्य अतिरिक्त कार्रवाई के साथ चुपचाप पृष्ठभूमि में जमा होता है।
आपको कैसे पता चलेगा कि यह रिकॉर्ड कर रहा है? इंटरफ़ेस संकेतों को देखें। अधिकारी कहते हैं कि जब आप Claude Code इंटरफ़ेस में "Writing memory" या "Recalled memory" पॉप अप देखते हैं, तो यह उस नोटबुक में लिख रहा होता है या उससे पढ़ रहा होता है।
💡 एक वाक्य का सारांश: ऑटो-मेमोरी Claude द्वारा लिखा गया एक स्टिकी नोट है—आप इसे याद रखने के लिए कहते हैं, या यह आपके सुधारों से खुद सीखता है, केवल वही याद रखता है जो "भविष्य में उपयोग किया जाएगा"; "Writing/Recalled memory" इंटरफ़ेस प्रॉम्प्ट देखना मतलब यह याद रख रहा है या नोटबुक को पलट रहा है।
04 इसे कहाँ रखा गया है, और इसे संदर्भ में कैसे लोड किया जाता है
यह खंड दो सबसे व्यावहारिक समस्याओं को हल करता है: यह नोटबुक वास्तव में किस फ़ाइल में संग्रहीत है? Claude को इसे "याद रखने" के लिए संदर्भ में कैसे भरा जाता है? दूसरा आधा पूरी तरह से [19] में उल्लिखित संदर्भ प्रबंधन को प्रतिध्वनित करता है।
भंडारण स्थान, जिसे आधिकारिक तौर पर तय किया गया है—प्रत्येक प्रोजेक्ट के लिए एक स्वतंत्र मेमोरी निर्देशिका:
~/.claude/projects/<project>/memory/
├── MEMORY.md # संक्षिप्त अनुक्रमणिका, प्रत्येक सत्र में लोड किया गया
├── debugging.md # डिबगिंग से संबंधित विस्तृत नोट्स
├── api-conventions.md # API डिज़ाइन निर्णय
└── ... # अन्य विषय फ़ाइलें जो Claude स्वयं बनाता हैअलग करने के लिए कुछ प्रमुख बिंदु:
MEMORY.md प्रवेश द्वार और अनुक्रमणिका है। यह स्टिकी नोट्स के "सामग्री तालिका पृष्ठ" की तरह है, जिसका उपयोग Claude यह ट्रैक करने के लिए करता है कि "मैंने क्या रिकॉर्ड किया है"। विस्तृत सामग्री के लिए, यह उन्हें debugging.md और api-conventions.md जैसी विषय फ़ाइलों में विभाजित कर देगा, ताकि MEMORY.md को लंबे और लंबे होने से रोका जा सके।
<project> नाम की गणना git रिपॉजिटरी के अनुसार की जाती है। तो—एक ही रिपॉजिटरी के सभी worktree और उपनिर्देशिकाएँ इस ऑटो-मेमोरी को साझा करती हैं। यह CLAUDE.md (CLAUDE.md निर्देशिका ट्री के अनुसार विभाजित है) से अलग है।
यह मशीन के लिए स्थानीय है और सभी उपकरणों में समन्वयित नहीं होता है। आपने इस कंप्यूटर पर जो रिकॉर्ड किया है, वह दूसरे कंप्यूटर में बदलने पर नहीं होगा। इसके git में जाने की उम्मीद न करें—यह सिर्फ आपके ~/.claude के तहत रहता है।
अगला है सबसे महत्वपूर्ण तंत्र जिसे समझने की आवश्यकता है—इसे संदर्भ में कैसे लोड किया जाता है, जिसे आधिकारिक तौर पर बहुत सख्ती से लिखा गया है:
MEMORY.mdकी पहली 200 पंक्तियाँ या पहली 25KB (जो भी पहले आए) प्रत्येक वार्तालाप की शुरुआत में लोड की जाती हैं। उस सीमा से अधिक सामग्री सत्र की शुरुआत में लोड नहीं की जाती है।
मानव भाषा में अनुवादित, इसके तीन अर्थ हैं:
- हर नए सत्र में, यह स्वचालित रूप से
MEMORY.mdकी पहली 200 पंक्तियों को पढ़ता है (या 25KB, जो भी पहले आए)। यह सिद्धांत है कि यह "क्रॉस-सत्रों को याद रखता है"—पिछली बार जो रिकॉर्ड किया गया था वह इस बार की शुरुआत में स्वचालित रूप से संदर्भ में प्रवेश करेगा। - 200 पंक्तियों / 25KB से अधिक वाला भाग शुरुआत में लोड नहीं होता है। इसलिए Claude सक्रिय रूप से
MEMORY.mdको सुव्यवस्थित रखेगा और विवरणों को विषय फ़ाइलों में फेंक देगा। - विषय फ़ाइलें (
debugging.mdआदि) शुरुआत में लोड नहीं होती हैं, यह आवश्यकतानुसार पढ़ने के लिए फ़ाइल टूल का उपयोग करता है—वही सिद्धांत "उपनिर्देशिका CLAUDE.md को मांग पर लोड किया जाता है" [18] में बात की गई है।
CLAUDE.md और ऑटो-मेमोरी के लोडिंग नियमों की एक साथ तुलना करें, और अंतर एक नज़र में स्पष्ट है:
| CLAUDE.md | ऑटो-मेमोरी MEMORY.md | |
|---|---|---|
| कितना लोड करना है | पूर्ण, चाहे कितना भी लंबा हो, यह लोड हो जाता है | केवल पहली 200 लाइनें / 25KB |
| अतिरिक्त भाग | अभी भी पूरी तरह से लोड है (इसलिए आपको इसे छोटा लिखने की सलाह दी जाती है) | शुरुआत में लोड नहीं हुआ, आवश्यकतानुसार पढ़ें |
| स्ट्रीमलाइनिंग कौन बनाए रखता है | आप मैन्युअल रूप से हटाते हैं | Claude स्वचालित रूप से विभाजित होता है |
इस ऊपरी सीमा को समझें, और आप समझ जाएंगे कि संदर्भ को स्मृति द्वारा "विस्फोट" क्यों नहीं किया जाएगा—ऑटो-मेमोरी जन्मजात 200-लाइन गेट के साथ आता है, जबकि CLAUDE.md के गेट को आपको स्वयं नियंत्रित करना होगा।
💡 एक वाक्य का सारांश: ऑटो-मेमोरी
~/.claude/projects/<project>/memory/MEMORY.mdमें संग्रहीत है, git रिपॉजिटरी द्वारा विभाजित, मशीन-स्थानीय, और worktree द्वारा साझा किया गया है; हर बार जब आप शुरू करते हैं, तो यह केवल पहली 200 पंक्तियों / 25KB को वापस पढ़ता है, और अतिरिक्त भाग विषय फ़ाइलों में विभाजित होते हैं और आवश्यकतानुसार पढ़े जाते हैं—इसलिए इसकी एक प्राकृतिक ऊपरी सीमा होती है और यह संदर्भ को नहीं फोड़ेगा।
05 /memory: ऑडिटिंग, एडिटिंग, स्विचिंग, एक कमांड यह सब करता है
ऑटो-मेमोरी के बारे में सबसे चिंताजनक बात यह है—इसने इसे स्वयं रिकॉर्ड किया है, क्या होगा यदि यह इसे गलत या पुरानी जानकारी रिकॉर्ड करता है? (शुरुआत में वह 8081 पोर्ट गड्ढा इसी तरह आया था।) आधिकारिक उत्तर एक आदेश है: /memory।
सादृश्य: स्टिकी नोट्स का एक स्टैक जिसे किसी भी समय उठाया जा सकता है। जो नोट्स वह खुद रखता है वे कोई ब्लैक बॉक्स नहीं हैं। यदि आप उन्हें देखना चाहते हैं, तो आप उन्हें किसी भी समय उठा सकते हैं, और यदि आप उन्हें फाड़ना चाहते हैं, तो आप उन्हें किसी भी समय फाड़ सकते हैं। /memory "उठाने और देखने" की क्रिया है।
सत्र में /memory टाइप करें, और यह तीन चीजें करता है:
- वर्तमान सत्र में लोड की गई सभी मेमोरी फ़ाइलों को सूचीबद्ध करें—CLAUDE.md, CLAUDE.local.md, नियम फ़ाइलें और ऑटो-मेमोरी सहित। अगर आपको शक है कि "इसने कुछ गलत याद रखा है", तो पहले यह जाँचने के लिए इसका उपयोग करें कि आखिर क्या लोड किया गया था।
- ऑटो-मेमोरी फ़ोल्डर खोलने के लिए एक प्रवेश द्वार प्रदान करें—प्रवेश करने के लिए
memory/निर्देशिका पर क्लिक करें। वे फ़ाइलें पूरी तरह से शुद्ध markdown हैं, आप उन्हें किसी भी समय पढ़, संशोधित और हटा सकते हैं। यदि कोई प्रविष्टि गलत याद की गई है, तो बस उसे हटा दें। - ऑटो-मेमोरी स्विच टॉगल करें—यदि आप नहीं चाहते कि यह अब स्वचालित रूप से रिकॉर्ड करे, तो आप इसे यहां बंद कर सकते हैं।
सत्र में /memory का उपयोग करने के अलावा, "स्विच को पिन करने" के दो आधिकारिक तरीके हैं:
settings.json में ऑटो-मेमोरी बंद करें (प्रोजेक्ट-स्तरीय, कॉन्फ़िगरेशन फ़ाइल में प्रभावी होने के लिए दीर्घकालिक):
{
"autoMemoryEnabled": false
}या इसे अस्थायी रूप से बंद करने के लिए पर्यावरण चर का उपयोग करें (बस CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 सेट करें)।
यह एक आदत विकसित करने लायक है: हर बार, अपने प्रोजेक्ट की नोटबुक को खोलने और स्कैन करने के लिए एक बार /memory टाइप करें। आप अक्सर कुछ ऐसे आइटम साफ़ कर सकते हैं जिन्हें बहुत पहले ही हटा दिया जाना चाहिए था—एक बदला हुआ पोर्ट, एक छोड़ दिया गया इंटरफ़ेस अनुबंध, एक "प्राथमिकता" जिसे आप खुद भी नहीं समझ सकते हैं। यह दो मिनट का काम है, ताकि किसी दिन यह आपको पुरानी जानकारी के साथ गुमराह न करे। 8081 वाले गड्ढे से हम ठीक यही सबक सीख सकते हैं।
💡 एक वाक्य का सारांश:
/memoryएक कमांड मेमोरी सिस्टम को फैला देता है—कौन सी फाइलें लोड हैं इसकी सूची बनाएं, फ़ोल्डर को पढ़ने, बदलने और हटाने के लिए खोलें, और ऑटो-मेमोरी को भी चालू और बंद कर सकते हैं; इसे नियमित रूप से खोलें और इसे स्कैन करें, और उन कुछ पुरानी प्रविष्टियों को साफ़ करें, जो "गलत याद रखने" को ठीक करने का सबसे आसान तरीका है।
06 क्या याद रखना है और क्या याद नहीं रखना है: "सब कुछ भरने" की गलती को न दोहराएं
तंत्र के बारे में बात करने के बाद, आइए सबसे व्यावहारिक निर्णय पर आते हैं—क्या इसे याद रखने देना उचित है, और क्या इसे बिल्कुल नहीं छुआ जाना चाहिए। इस खंड में सभी अनुभव गड्ढों से सीखे गए हैं।
अच्छी खबर यह है कि ऑटो-मेमोरी डिफ़ॉल्ट रूप से अपेक्षाकृत संयमित है (यह केवल वही याद रखती है जो "भविष्य में उपयोगी होगा")। लेकिन जब आप सक्रिय रूप से इसे याद रखने के लिए कहते हैं, तो आपको इसे खुद जांचना होगा—आप कहते हैं "xxx याद रखें", यह आमतौर पर इसे वास्तव में याद रखता है, और यह सब आप पर निर्भर करता है कि इसे जांचना है या नहीं।
आइए सीधे तुलना तालिका पर जाएं, बाईं ओर वह है जिसे भरने पर आपको पछतावा होगा, और दाईं ओर वह है जिसे वास्तव में याद रखा जाना चाहिए:
| ❌ इसे याद न रखने दें (एकमुश्त / बदल जाएगा / संवेदनशील) | ✅ याद रखने योग्य (स्थिर / पुन: प्रयोज्य / परियोजना-विशिष्ट) |
|---|---|
| "इस बार 8081 पोर्ट का उपयोग करें" (एकमुश्त) | "बिल्ड कमांड make build है न कि npm build" |
"अस्थायी रूप से इस चर को tmp में बदलें" (अस्थायी) | "इस प्रोजेक्ट के परीक्षण को पहले स्थानीय रूप से Redis शुरू करना होगा" |
| "चलिए इस संस्करण को अभी के लिए इस तरह चलाते हैं" (जल्द ही बदल जाएगा) | "पिछली बार उस कभी-कभार आने वाले बग का मूल कारण यह था कि समय क्षेत्र सेट नहीं किया गया था" (डिबगिंग अंतर्दृष्टि) |
| डेटाबेस पासवर्ड / API key / token (संवेदनशील!) | "तारीख समान रूप से ISO 8601 प्रारूप का उपयोग करती है" (अनुबंध प्राथमिकता) |
| "मैं अभी लॉगिन पेज को डिबग कर रहा हूँ" (इस बार अस्थायी स्थिति) | "प्रमाणीकरण तर्क सब src/auth/ में है" (वास्तुकला तथ्य) |
निर्णय के तीन सिद्धांत, बस इन तीन शब्दों को याद रखें और यह पर्याप्त है:
पहला है "क्या यह बदलेगा"। एकमुश्त, जो जल्द ही बदल दिया जाएगा, "अभी के लिए बस यही", बिल्कुल याद न रखें—उनकी शेल्फ लाइफ आपके वर्तमान सत्र से छोटी है, और उन्हें याद रखना भविष्य के लिए एक गड्ढा खोदना है। वह 8081 एक विशिष्ट उदाहरण है, यह उस समय उपयोगी था जब इसे डिबग किया गया था, लेकिन दो दिन बाद यह भ्रामक होगा।
दूसरा है "क्या इसका पुन: उपयोग किया जा सकता है"। केवल वही जो इस बार उपयोग किया जा सकता है ("मैं वर्तमान में X डिबग कर रहा हूँ"), याद न रखें; क्या अगली बार, और उसके बाद अगली बार उपयोग किया जा सकता है (कमांड, आर्किटेक्चरल तथ्य, गड्ढे जिन्हें आपने कदम रखा है), याद रखने योग्य है।
तीसरा है "क्या यह संवेदनशील है"। यह नियम एक लाल रेखा है—पासवर्ड, टोकन और API कुंजियों को कभी भी किसी भी मेमोरी फ़ाइल में नहीं आना चाहिए। ऑटो-मेमोरी आपकी हार्ड ड्राइव पर शुद्ध मार्कडाउन प्लेनटेक्स्ट के रूप में मौजूद है, और इसमें कुंजियों को रिकॉर्ड करना डिस्क पर प्लेनटेक्स्ट छोड़ने के बराबर है। यह वैश्विक सुरक्षा बाधाओं के अनुरूप है: संवेदनशील जानकारी कोड, कमिट या लॉग में प्रवेश नहीं करती है, और स्वाभाविक रूप से यह मेमोरी में प्रवेश नहीं करती है।
इसे याद रखने से पहले, बस इन तीन परीक्षणों को अपने दिमाग में पार करें: क्या यह बदल जाएगा? क्या यह भविष्य में उपयोगी होगा? क्या यह संवेदनशील है? केवल जब तीनों परीक्षण पास हो जाते हैं तो आप इसे याद रखने दे सकते हैं। इस तरह की जाँच के बाद, इसकी नोटबुक बहुत साफ हो जाएगी, और यह अब आपको पुरानी जानकारी के साथ गुमराह नहीं करेगी।
💡 एक वाक्य का सारांश: याद रखने से पहले तीन जांच पास करें—बदलने वाली चीजों को याद न रखें, जो केवल एक बार उपयोग की जाती हैं उन्हें याद न रखें, और जो संवेदनशील हैं उन्हें बिल्कुल याद न रखें; केवल उन तथ्यों और अनुभवों को याद रखें जो "स्थिर, पुन: प्रयोज्य और परियोजना-विशिष्ट" हैं, सब कुछ इसमें न भरें।
07 क्या पुराने शॉर्टकट कुंजी # का अभी भी उपयोग किया जा सकता है?
ℹ️
#शुरुआती दिनों में एक पुराना अभ्यास है, और नया संस्करण अब इस इंटरैक्शन का उपयोग नहीं करता है। कई पुराने ट्यूटोरियल और वीडियो अभी भी सिखा रहे हैं "मेमोरी को जल्दी से जोड़ने के लिए शुरुआत में#का उपयोग करें", बस इसे भूल जाएं। वर्तमान सही प्रवेश द्वार है: "xxx याद रखें" कहें और यह ऑटो-मेमोरी में सहेजा जाएगा, "CLAUDE.md में जोड़ें" कहें और यह git नियमों में सहेजा जाएगा, और जांचने, बदलने और हटाने के लिए/memoryका उपयोग करें।सबसे आम जाल जिसमें नौसिखिए कदम रखते हैं: बस "xxx याद रखें" कहने से, यह डिफ़ॉल्ट रूप से ऑटो-मेमोरी (स्थानीय मशीन) में सहेजा जाता है, जो CLAUDE.md में प्रवेश करने के बराबर नहीं है (git में, पूरी टीम द्वारा साझा किया गया)। यदि आप चाहते हैं कि पूरी टीम एक निश्चित नियम देखे, तो आपको स्पष्ट रूप से कहना होगा "CLAUDE.md में जोड़ें"। एक वाक्य का अंतर, साझा करने का दायरा दुनिया भर में अलग है।
💡 एक वाक्य का सारांश:
#पुराना है, इसका उपयोग न करें; "xxx याद रखें" ऑटो-मेमोरी में जाता है, "CLAUDE.md में जोड़ें" git में जाता है—दोनों एक ही बात नहीं हैं, यदि आप साझा करना चाहते हैं, तो आपको पूरी बात कहनी होगी।
08 करो: एक प्रविष्टि याद रखें, देखें कि यह कहाँ आती है, और अगली बार स्वचालित रूप से प्रभावी होती है
सिर्फ देखना और अभ्यास न करना इसे जानने के रूप में नहीं गिना जाता है। नीचे मैं आपको पूरी प्रक्रिया से गुज़रूँगा: इसे एक प्रविष्टि याद रखने दें → पुष्टि करें कि यह ऑटो-मेमोरी फ़ाइल में आ गया है → सत्यापित करें कि अगला सत्र इसे स्वचालित रूप से याद रखता है। पूरी प्रक्रिया एक न्यूनतम उदाहरण है और किसी भी जटिल वातावरण पर निर्भर नहीं करती है।
ℹ️ शर्त:
claude --version≥ v2.1.59, और ऑटो-मेमोरी बंद नहीं है (यह डिफ़ॉल्ट रूप से चालू है)।
चरण 1: एक खिलौना प्रोजेक्ट बनाएं और Claude शुरू करें (Mac / Linux)
mkdir memory-demo
cd memory-demo
claudeअपेक्षा: Claude Code सत्र इंटरफ़ेस दर्ज करें, और नीचे एक इनपुट बॉक्स है।
चरण 2: इसे एक प्रविष्टि याद रखने दें
इनपुट बॉक्स में टाइप करें (एक विशिष्ट "बिल्ड कमांड" का उपयोग करें जो याद रखने योग्य है):
याद रखें: इस प्रोजेक्ट का बिल्ड कमांड make build है, npm build नहींअपेक्षा: Claude जवाब देगा कि उसने इसे नोट कर लिया है, और एक "Writing memory" जैसा प्रॉम्प्ट इंटरफ़ेस पर फ्लैश होगा—इस प्रॉम्प्ट को देखने का मतलब है कि यह उस नोटबुक में लिख रहा है।
चरण 3: पुष्टि करने के लिए /memory का उपयोग करें कि यह किस फ़ाइल में आया है
इसके तुरंत बाद टाइप करें:
/memoryअपेक्षा: एक मेमोरी प्रबंधन इंटरफ़ेस पॉप अप होता है, जो वर्तमान में लोड की गई सभी मेमोरी फ़ाइलों को सूचीबद्ध करता है। आप ऑटो-मेमोरी का प्रवेश द्वार देख सकते हैं, और जब आप इस पर क्लिक करते हैं, तो आप MEMORY.md देख सकते हैं, जिसमें अभी वह make build रिकॉर्ड शामिल है। इसे फ़ाइल में देखने का अर्थ है = यह प्रविष्टि "बातचीत में इसके बारे में बात करने" से "डिस्क पर सहेजे गए नोट्स" में बदल गई है।
यदि आप कमांड लाइन से सीधे इसकी पुष्टि करना चाहते हैं, तो आप एक अन्य टर्मिनल खोल सकते हैं और टाइप कर सकते हैं:
cat ~/.claude/projects/*memory-demo*/memory/MEMORY.mdअपेक्षा: आउटपुट में, आप अभी रिकॉर्ड किए गए बिल्ड कमांड को देख सकते हैं (विशिष्ट पथ में <project> नाम की गणना आपकी निर्देशिका के अनुसार की जाती है, बस मिलान करने के लिए * का उपयोग करें)। शुद्ध मार्कडाउन, एक नज़र में पढ़ा जा सकता है।
चरण 4: सत्यापित करें कि अगला सत्र स्वचालित रूप से प्रभावी होता है
यह कदम महत्वपूर्ण है—स्मृति का अर्थ "क्रॉस-सत्र" है। वर्तमान सत्र से बाहर निकलें:
/exitफिर पुनरारंभ करें, और उससे एक प्रश्न पूछें जो उस मेमोरी का उपयोग करेगा:
claudeअंदर जाने के बाद टाइप करें:
इस प्रोजेक्ट को कैसे बनाया जाए?अपेक्षा: यह सीधे आपको make build का उपयोग करने के लिए कहेगा (अंधाधुंध npm build का अनुमान लगाने के बजाय)—और आप "Recalled memory" प्रॉम्प्ट देख सकते हैं, जो दर्शाता है कि इसने नोटबुक से पिछली बार रिकॉर्ड की गई सामग्री को वापस पढ़ लिया है। इसने नए सत्र में सही उत्तर दिया = क्रॉस-सत्र मेमोरी पूरी तरह से चली गई, बधाई हो!
चरण 5 (वैकल्पिक): इस प्रविष्टि को साफ़ करें और सत्यापित करें कि विलोपन भी प्रभावी होता है
/memory टाइप करें, ऑटो-मेमोरी फ़ोल्डर में प्रवेश करें, उस make build प्रविष्टि को हटा दें और इसे सहेजें। अगली बार जब आप "कैसे बनाएं" पूछेंगे, तो यह अब निश्चित रूप से make build की रिपोर्ट नहीं करेगा—गलत तरीके से याद की गई प्रविष्टि हटा दिए जाने पर साफ हो जाएगी, यह बिल्कुल "उठाने और फाड़ने" की शक्ति है जो /memory आपको देती है।
इन पांच चरणों को चलाने के बाद, आपने व्यक्तिगत रूप से "एक प्रविष्टि याद रखें → डिस्क पर सहेजें → क्रॉस-सत्रों में स्वचालित रूप से याद रखें → किसी भी समय ऑडिट और हटाएं" के पूरे लिंक को सत्यापित किया है। भविष्य में, मेमोरी से संबंधित सभी गेमप्ले अनिवार्य रूप से इस तंत्र पर आधारित होंगे।
💡 एक वाक्य का सारांश: इसे "xxx याद रखें" → "Writing memory" प्रॉम्प्ट देखें →
/memoryयाcatयह पुष्टि करने के लिए कि यहMEMORY.mdमें आ गया है → बाहर निकलें और फिर से प्रवेश करें, यह "Recalled memory" स्वचालित रूप से सही उत्तर देता है → आवश्यकतानुसार हटाने और बदलने के लिए/memory। इस लिंक को व्यक्तिगत रूप से चलाना दस अवधारणाओं को याद रखने से अधिक उपयोगी है।
09 सारांश
इस लेख ने Claude Code के "मेमोरी सिस्टम" को शुरू से ही स्पष्ट कर दिया है—यह एक सेट नहीं है, यह समानांतर में दो सेट है; यह ऐसा नहीं है कि आप जितना अधिक भरेंगे, उतना ही बेहतर होगा, बल्कि जो याद रखा जाना चाहिए वह सटीक रूप से याद रखा जाना चाहिए।
समीक्षा के लिए मुख्य बिंदुओं को एक साथ बांधें:
| आपको क्या पता लगाने की आवश्यकता है | निष्कर्ष |
|---|---|
| मेमोरी को कितने सेट में बांटा गया है | दो सेट: CLAUDE.md आपके हस्तलिखित नियम हैं + ऑटो-मेमोरी यह खुद अनुभव याद रखता है |
| दो सेटों के बीच अंतर कैसे करें | किसने लिखा, इसमें नियम हैं या अनुभव, यह पूरी तरह से लोड है या इसकी ऊपरी सीमा है—एक तालिका इसे स्पष्ट कर सकती है |
| ऑटो-मेमोरी कहाँ संग्रहीत है | ~/.claude/projects/<project>/memory/MEMORY.md, git रिपॉजिटरी द्वारा विभाजित, मशीन-स्थानीय |
| इसे कैसे लोड किया जाता है | शुरुआत में केवल MEMORY.md की पहली 200 लाइनें / 25KB वापस पढ़ता है, और अतिरिक्त हिस्से विषय फ़ाइल में विभाजित होते हैं और आवश्यकतानुसार पढ़े जाते हैं |
| ऑडिट, डिलीट और बदलाव कैसे करें | /memory: लोड की गई फाइलों को सूचीबद्ध करें, पढ़ने, बदलने और हटाने के लिए फ़ोल्डर्स खोलें, ऑटो-मेमोरी को चालू और बंद करें |
| क्या याद रखना है बनाम क्या याद नहीं रखना है | तीन जांच पास करें: जो बदल जाएगा, जो केवल एक बार उपयोग किया जाता है, जो संवेदनशील है—इनमें से किसी को भी याद न रखें |
क्या # का अभी भी उपयोग किया जा सकता है? | पुराना हो गया; अब ऑटो-मेमोरी में प्रवेश करने के लिए "xxx याद रखें" कहें, और git में प्रवेश करने के लिए "CLAUDE.md में जोड़ें" कहें |
अब आपको सक्षम होना चाहिए: स्पष्ट रूप से अलग करें कि CLAUDE.md और ऑटो-मेमोरी किस चीज के लिए जिम्मेदार हैं, वे कहां संग्रहीत हैं, और वे कैसे लोड होते हैं; Claude को एक प्रविष्टि याद रखने दें और पुष्टि करें कि यह किस फ़ाइल में गिरती है; गलत और पुराने नोट्स को साफ़ करने के लिए /memory का उपयोग करें; और यह भी कि क्या जानकारी का एक टुकड़ा याद रखा जाना चाहिए। स्पष्ट रूप से कहें तो—आप Claude को "जो याद रखा जाना चाहिए उसे याद रखने, और जो भूल जाना चाहिए उसे भूलने" दे सकते हैं, बजाय इसके कि वह आपको भ्रमित करने के लिए बेकार की चीजों से अपना दिमाग भर ले।
मेमोरी, संक्षेप में, Claude है जो "तथ्यों को निष्क्रिय रूप से याद रखता है"—आप उसे सही करते हैं, और वह जमा होता है। लेकिन यह आपके लिए जो कर सकता है वह याद रखने से कहीं अधिक है।
अगला लेख 26 "Agent Skills"—मेमोरी "तथ्यों को निष्क्रिय रूप से याद रखना" है, जबकि Skills "क्षमता को सक्रिय रूप से इनकैप्सुलेट करना" है: उस कार्य के एक सेट को पैकेज करें जिसे आप बार-बार चाहते हैं कि वह एक "विशेष कौशल" में करे जिसे वह मांग पर कॉल कर सकता है। अगर मेमोरी उसे "आपको बेहतर समझने" में मदद करती है, तो Skills उसे "अधिक सक्षम" बनाती है। एक छोटा सा विचार छोड़ें: इसी तरह "Claude को पहले से तैयार करने दें", आपको क्या लगता है कि "एक नियम याद रखें" और "एक कौशल सीखें" का उपयोग कब किया जाना चाहिए?