एक केस स्टडी: कैसे Claude 92% कैश हिट-रेट हासिल करता है
हर बार जब कोई AI एजेंट एक कदम उठाता है, तो वह एक टैक्स चुकाता है।
वह सब कुछ फिर से शुरू से पढ़ता है।
सिस्टम इंस्ट्रक्शन। टूल डेफ़िनिशन। वह प्रोजेक्ट कॉन्टेक्स्ट जो उसने तीन टर्न पहले ही लोड कर लिया था। सब कुछ। हर एक टर्न पर।
यही है कॉन्टेक्स्ट टैक्स। और लंबे समय तक चलने वाले एजेंटिक वर्कफ़्लो के लिए, यह अक्सर आपके पूरे AI इंफ्रास्ट्रक्चर में सबसे महंगा आइटम होता है।
यहाँ गणित है: 20,000 टोकन का एक सिस्टम प्रॉम्प्ट जो 50 टर्न में चलता है, इसका मतलब है 1 मिलियन टोकन का बेकार कम्प्यूटेशन जो पूरी कीमत पर बिल किया जाता है, और कोई नया मूल्य उत्पन्न नहीं करता है।
हल है प्रॉम्प्ट कैशिंग। लेकिन इसका अच्छी तरह से उपयोग करने के लिए, आपको यह समझना होगा कि वास्तव में अंदर क्या हो रहा है।
उससे शुरू करें जो बदलता है और जो नहीं बदलता
इससे पहले कि आप किसी भी चीज़ को ऑप्टिमाइज़ कर सकें, आपको एक एजेंट के प्रॉम्प्ट (कॉन्टेक्स्ट) की संरचना के बारे में स्पष्ट रूप से सोचने की ज़रूरत है।
आपका एजेंट जो भी अनुरोध भेजता है, उसके दो मौलिक रूप से अलग-अलग हिस्से होते हैं:
स्टैटिक प्रीफ़िक्स: इसमें सिस्टम इंस्ट्रक्शन, टूल डेफ़िनिशन, प्रोजेक्ट कॉन्टेक्स्ट, व्यवहार संबंधी दिशा-निर्देश शामिल हैं। यह सामग्री एक सत्र के हर एक टर्न पर समान होती है।
डायनैमिक टेल: यूज़र मैसेज, टूल आउटपुट, टर्मिनल ऑब्ज़र्वेशन। यह हर अनुरोध के लिए अद्वितीय होता है और जैसे-जैसे बातचीत आगे बढ़ती है, बढ़ता जाता है।
यह अंतर सब कुछ है। स्टैटिक प्रीफ़िक्स वह महंगा हिस्सा है जिसे आप बिना किसी कारण के बार-बार कंप्यूट करते रहते हैं। डायनैमिक टेल एकमात्र ऐसा हिस्सा है जिसे वास्तव में ताज़ा कम्प्यूटेशन की आवश्यकता होती है।
प्रॉम्प्ट कैशिंग स्टैटिक प्रीफ़िक्स की गणितीय स्थिति को संग्रहीत करके काम करती है, ताकि भविष्य के अनुरोध इसे पूरी तरह से फिर से कंप्यूट करने से बच सकें। आप उस प्रीफ़िक्स को एक बार प्रोसेस करने के लिए भुगतान करते हैं। हर बाद का टर्न मेमोरी से पढ़ता है।
यह क्यों काम करता है: एक ट्रांसफ़ॉर्मर वास्तव में क्या करता है
यह वास्तव में समझने के लिए कि कैशिंग इतनी प्रभावी क्यों है, आपको यह समझने की ज़रूरत है कि जब मॉडल आपका प्रॉम्प्ट पढ़ता है तो अंदर क्या होता है।
हर LLM इन्फ़रेंस अनुरोध के दो चरण होते हैं:
चरण 1: प्रीफ़िल
यह वह जगह है जहाँ मॉडल आपके पूरे इनपुट प्रॉम्प्ट को प्रोसेस करता है। यह कंप्यूट-बाउंड है, जिसका अर्थ है कि यह आपके कॉन्टेक्स्ट के हर टोकन पर डेंस मैट्रिक्स मल्टीप्लिकेशन चलाता है। मॉडल सब कुछ पढ़ता है और उसका एक प्रतिनिधित्व बनाता है। यह धीमा, महंगा चरण है।
चरण 2: डिकोड
यह वह जगह है जहाँ मॉडल एक बार में एक आउटपुट टोकन उत्पन्न करता है। यह कंप्यूट-बाउंड के बजाय मेमोरी-बाउंड है क्योंकि मॉडल अपना अधिकांश समय पहले से कंप्यूट की गई स्थिति को पढ़ने में बिताता है, न कि भारी गणना करने में।
प्रीफ़िल चरण के दौरान, ट्रांसफ़ॉर्मर प्रत्येक टोकन के लिए तीन वेक्टर बनाता है: एक क्वेरी, एक की और एक वैल्यू। अटेंशन मैकेनिज़्म यह पता लगाने के लिए इनका उपयोग करता है कि प्रत्येक टोकन अनुक्रम में हर दूसरे टोकन से कैसे संबंधित है।
यहाँ महत्वपूर्ण अंतर्दृष्टि है: की और वैल्यू वेक्टर केवल उन टोकन पर निर्भर करते हैं जो उनसे पहले आए थे। एक बार जब वे किसी दिए गए प्रीफ़िक्स के लिए गणना कर लिए जाते हैं, तो उन्हें कभी बदलने की आवश्यकता नहीं होती है।
नीचे दिया गया चित्रण दृश्य रूप से समझाता है कि हमने अभी क्या चर्चा की:
कैशिंग के बिना, वे की-वैल्यू टेंसर अनुरोध पूरा होते ही फेंक दिए जाते हैं। अगला अनुरोध शुरू से शुरू होता है और उन सभी 20,000 टोकन के लिए उनकी पुनर्गणना करता है।
KV कैशिंग उन टेंसरों को संग्रहीत करके इसे हल करता है। इंफ्रास्ट्रक्चर उन्हें इन्फ़रेंस सर्वर पर रखता है, जो इनपुट टेक्स्ट के क्रिप्टोग्राफ़िक हैश द्वारा अनुक्रमित होते हैं। जब उसी प्रीफ़िक्स के साथ एक नया अनुरोध आता है, तो हैश मैच हो जाता है, टेंसर तुरंत पुनर्प्राप्त हो जाते हैं, और मॉडल उस सारी गणना को छोड़ देता है।
यह कम्प्यूटेशनल जटिलता को प्रति उत्पन्न टोकन O(n²) से घटाकर O(n) कर देता है। 50 टर्न में दोहराए गए 20,000-टोकन प्रीफ़िक्स के लिए, यह एक बहुत बड़ी कमी है।
अर्थशास्त्र
मूल्य निर्धारण संरचना को समझना ही इस आर्किटेक्चरल निर्णय को इतना महत्वपूर्ण बनाता है।
यहाँ बताया गया है कि कैसे Anthropic अपने मॉडल परिवारों में कैशिंग की कीमत तय करता है:
ध्यान में रखने योग्य तीन आंकड़े:
- कैश रीड की कीमत बेस इनपुट कीमत का 10% है, जो कैश से पढ़े गए हर टोकन पर 90% छूट है
- कैश राइट की कीमत बेस इनपुट कीमत से 25% अधिक है, जो KV टेंसर को स्टोर करने के लिए एक छोटा प्रीमियम है
- विस्तारित 1-घंटे की कैशिंग की कीमत बेस कीमत से 2 गुना है
गणित तभी काम करता है जब आपकी कैश हिट दर उच्च बनी रहे। जो हमें सबसे अच्छे वास्तविक दुनिया के उदाहरण पर लाता है कि व्यवहार में यह कैसा दिखता है।
Claude Code: एक 30-मिनट के सत्र का वॉकथ्रू
Claude Code पूरी तरह से एक उद्देश्य के आसपास बनाया गया है: कैश को हॉट रखना।
यह समझने के लिए कि इसका ठोस रूप से क्या मतलब है, आइए देखें कि एक विशिष्ट 30 मिनट का कोडिंग सत्र कैसा दिखता है और ट्रैक करें कि वास्तव में क्या बिल किया जाता है और क्या नहीं।
मिनट 0: सत्र शुरू
Claude Code अपना सिस्टम प्रॉम्प्ट और टूल डेफ़िनिशन लोड करता है। यह आपके प्रोजेक्ट रूट में CLAUDE.md फ़ाइल भी पढ़ता है, जो कोडबेस और कन्वेंशन का वर्णन करती है। यह पेलोड नियमित रूप से 20,000 टोकन से अधिक होता है।
यह पूरे सत्र का सबसे महंगा क्षण है। हर एक टोकन नया है। लेकिन आप यह लागत केवल एक बार चुकाते हैं।
मिनट 1 से 5: पहले कमांड
आप अपना पहला निर्देश टाइप करते हैं, जैसे "auth मॉड्यूल को देखें और सुधार सुझाएं।"
Claude Code एक Explore Subagent भेजता है। यह कोडबेस में नेविगेट करता है, फ़ाइलें खोलता है, grep कमांड चलाता है, और प्रासंगिक कोड की एक तस्वीर बनाता है। यह सब डायनैमिक टेल में जुड़ जाता है।
20,000-टोकन वाली स्टैटिक फ़ाउंडेशन? पहले से ही कैश में। $3.00/MTok के बजाय $0.30/MTok पर वापस पढ़ा जा रहा है। आप केवल नए टूल आउटपुट और अपने मैसेज के लिए भुगतान कर रहे हैं।
मिनट 6 से 15: गहरा काम
Plan Subagent को Explore Subagent से निष्कर्ष प्राप्त होते हैं। कच्चे परिणामों को शब्दशः पास करने के बजाय (जो अनावश्यक रूप से डायनैमिक टेल को बढ़ा देगा), Claude Code एक संक्षिप्त सारांश पास करता है। यह सफ़िक्स को प्रबंधनीय और कैश को कुशल रखता है।
प्लानर एक संरचित कार्यान्वयन योजना तैयार करता है। आप इसकी समीक्षा करते हैं, इसे मंज़ूरी देते हैं, और Claude Code बदलाव करना शुरू कर देता है। इस लूप में हर टर्न 20,000-टोकन प्रीफ़िक्स को कैश से पढ़ता है। प्रत्येक कैश हिट TTL को रीसेट करता है, भविष्य के टर्न के लिए कैश को गर्म रखता है।
मिनट 16 से 25: पुनरावृत्ति
आप समायोजन के लिए कहते हैं। Claude Code अपने दृष्टिकोण को संशोधित करता है। अधिक टूल कॉल, अधिक टर्मिनल आउटपुट। डायनैमिक टेल बढ़ रही है, लेकिन यह इस सत्र में केवल नई, अद्वितीय सामग्री का प्रतिनिधित्व करती है।
इस बिंदु पर, सत्र ने कुल मिलाकर सैकड़ों हज़ारों टोकन प्रोसेस किए हैं। लेकिन 20,000-टोकन फ़ाउंडेशन हर एक टर्न पर कैश से पढ़ा गया है।
मिनट 28: /cost चलाना
कैशिंग के बिना, इस तरह का सत्र आसानी से 2 मिलियन टोकन पार कर जाता है। Sonnet 4.5 दरों पर, यह लगभग $6.00 है।
उच्च दक्षता पर चल रही कैशिंग के साथ:
- अधिकांश टोकन $0.30/MTok पर कैश से पढ़े जाते हैं
- केवल नए डायनैमिक टेल टोकन ही ताज़ा कंप्यूट किए जाते हैं
व्यवहार में, आप एक एकल कार्य पर 80%+ लागत में कमी की उम्मीद कर सकते हैं। अब इसे हर उपयोगकर्ता, हर दिन से गुणा करें।
संक्षेप में, यहाँ बताया गया है कि सत्र जारी रहने पर सिस्टम प्रॉम्प्ट लेआउट कैसा दिखता है:
वह नियम जो सब कुछ तोड़ देता है
प्रॉम्प्ट कैशिंग के बारे में यह सबसे उल्टा-सीधा तथ्य है।
1 + 2 = 3. लेकिन 2 + 1 एक कैश मिस है।
इंफ्रास्ट्रक्चर प्रॉम्प्ट को हैश करता है। हैश क्रिप्टोग्राफ़ी के लिए एक पहचानकर्ता है। यदि उस क्रम में कुछ भी बदलता है तो हैश बदल जाता है, भले ही दो तत्व अलग-अलग क्रम में हों। कैश खाली है। पूरे प्रीफ़िक्स की पूरी कीमत पर पुनर्गणना की जाती है।
इससे अनुसरण करने वाले तीन नियम:
- सत्र के दौरान टूल न जोड़ें और न ही हटाएँ। कैश किए गए प्रीफ़िक्स में टूल शामिल हैं। टूल बदलने से उसके बाद आने वाली हर चीज़ बेकार हो जाती है।
- सत्र के बीच में कभी भी मॉडल न बदलें। कैश मॉडल-विशिष्ट होते हैं। बातचीत के बीच में सस्ते मॉडल पर स्विच करने के लिए पूरे कैश के पुनर्निर्माण की आवश्यकता होती है।
- स्थिति बदलने के लिए प्रीफ़िक्स कभी न बदलें। इसके बजाय, Claude Code अगले उपयोगकर्ता संदेश में एक टैग जोड़ता है जो सिस्टम को याद दिलाता है। प्रीफ़िक्स कभी नहीं बदलता है।
इसका आपके लिए क्या मतलब है
ऊपर सब कुछ बताता है कि Claude Code कैशिंग को कैसे संभालता है। यदि आप अपना खुद का एजेंट बना रहे हैं तो भी यही नियम लागू होते हैं।
अपने प्रॉम्प्ट को इस प्रकार संरचित करें:
- सबसे ऊपर सिस्टम इंस्ट्रक्शन और नियम हैं। बीच में न बदलें।
- आपको जितने भी टूल की आवश्यकता होगी, उन सभी को पहले से लोड करें। उन्हें न जोड़ें और न ही हटाएँ।
- उसके बाद पुनर्प्राप्त संदर्भ और दस्तावेज़। अवधि के लिए स्थिर।
- सबसे नीचे, बातचीत का इतिहास और टूल के आउटपुट।
ऑटो-कैशिंग चालू होने पर, ब्रेकपॉइंट बातचीत जारी रहने पर स्वचालित रूप से आगे बढ़ता है।
Claude Code अपने स्वयं के कैश का प्रभारी है। Anthropic ने अपने API में ऑटो-कैशिंग जोड़ दी है, ताकि आप अपने स्वयं के एजेंट के लिए भी ऐसा कर सकें।
ऑटो-कैशिंग के बिना, आपको यह याद रखना होता था कि टोकन सीमाएँ कहाँ थीं। एक गलत सीमा का मतलब था कैश तक न पहुँच पाना।
कॉन्टेक्स्ट सीमा को कॉम्पैक्ट करने के लिए कैश-सेफ़ फ़ोर्किंग का उपयोग करें। उसी सिस्टम प्रॉम्प्ट, टूल और बातचीत का उपयोग करें, फिर एक नए संदेश के रूप में कॉम्पैक्शन जोड़ें।
कॉम्पैक्शन कॉल लगभग पिछले एक जैसा ही दिखता है। कैश किए गए प्रीफ़िक्स का फिर से उपयोग किया जाता है। एकमात्र चीज़ जो नए के रूप में बिल की जाती है, वह है कॉम्पैक्शन इंस्ट्रक्शन।
यह देखने के लिए कि कोई API काम कर रहा है या नहीं, हर प्रतिक्रिया में इन तीन फ़ील्ड पर नज़र रखें:
- cache_creation_input_tokens: मेमोरी में डाले गए टोकन
- cache_read_input_tokens: मेमोरी से पढ़े गए टोकन
- input_tokens: सामान्य रूप से काम किए गए टोकन
आपका कैश दक्षता स्कोर क्रिएशन टोकन की संख्या की तुलना में रीड टोकन की संख्या है। इसे उसी तरह देखते रहें जैसे आप अपटाइम पर नज़र रखते हैं।
मुख्य निष्कर्ष
प्रॉम्प्ट कैशिंग कोई ऐसी सुविधा नहीं है जिसे आप चालू करते हैं। यह एक आर्किटेक्चरल अनुशासन है जिसके चारों ओर आप निर्माण करते हैं।
Claude Code इस बात का सबसे अच्छा उदाहरण है कि जब इसे बड़े पैमाने पर किया जाता है तो वह क्षेत्र कैसा दिखता है।
92% की कैश हिट दर। लागत में 81% की कटौती।
यदि आप एजेंट बना रहे हैं तो यह खाका है। आप टैक्स को नज़रअंदाज़ नहीं कर सकते; यह मौजूद है। एकमात्र चीज़ जो मायने रखती है, वह यह है कि क्या आप इसके लिए भुगतान कर रहे हैं या इससे छुटकारा पा रहे हैं।
