### त्वरित उत्तर: Claude को कम टोकन का उपयोग कैसे कराएं
Claude Code में टोकन खपत को 75% तक कम करने के लिए चार प्रमुख कदम उठाएं: बिल्ड आर्टिफैक्ट और लॉकफाइल को हटाने के लिए एक सख्त
.claudeignoreफ़ाइल बनाएं, स्थिर सिस्टम प्रॉम्प्ट के जरिए Anthropic के 90% प्रॉम्प्ट कैशिंग डिस्काउंट का लाभ उठाएं, Context Rot को रोकने के लिए Scout सब-एजेंट्स के जरिए सब-टास्क को अलग करें, और रूटीन कोड सर्च के लिए Opus के बजायclaude-3-7-sonnetया हल्केclaude-3-5-haikuमॉडल को प्राथमिकता दें।
1. परिचय: टर्मिनल कोडिंग एजेंटों में टोकन की गुप्त बर्बादी
Anthropic के Claude Code जैसे स्वायत्त टर्मिनल कोडिंग एजेंटों ने सॉफ्टवेयर विकास की रूपरेखा बदल दी है। सामान्य IDE ऑटो-कम्प्लीशन के विपरीत, Claude Code एक स्वायत्त लूप में कार्य करता है: यह डायरेक्टरी संरचना का निरीक्षण करता है, हजारों पंक्तियों की कोड फ़ाइलों को पढ़ता है, शेल कमांड निष्पादित करता है, कंपाइलर त्रुटियों का विश्लेषण करता है और सीधे कोडबेस में सटीक पैच लागू करता है।
हालाँकि, इस स्वायत्तता की एक भारी API लागत होती है। यदि उचित कॉन्फ़िगरेशन न किया जाए, तो "JWT रोटेशन के समर्थन के लिए ऑथेंटिकेशन मिडलवेयर को रीफैक्टर करें" जैसा सामान्य अनुरोध भी एक ही सत्र में 1.5M से 3.5M टोकन जला सकता है। इस टोकन वृद्धि के चार मुख्य कारण हैं:
- कॉन्टेक्स्ट का संचय और प्रदूषण (Context Rot): हर bash कमांड का आउटपुट, grep परिणाम, कंपाइलर त्रुटियां और पूरी फ़ाइलों के डंप सक्रिय कॉन्टेक्स्ट विंडो में जमा होते रहते हैं।
- बिना कैश की दोबारा लोडिंग: बातचीत की पिछली पंक्तियों में अनजाने में किए गए बदलाव Anthropic के 5-मिनट के अस्थायी प्रॉम्प्ट कैश को अमान्य कर देते हैं।
- अनावश्यक फ़ाइलों की स्कैनिंग: रेगेक्स सर्च के दौरान Claude Code बार-बार बिल्ड फ़ोल्डर (
dist/,target/,.next/), विशाल लॉकफाइल (package-lock.json,pnpm-lock.yaml) और डेटाबेस डंप को पढ़ लेता है। - ज़रूरत से बड़े मॉडल का चुनाव: सामान्य फ़ाइल सर्च या डायरेक्टरी नेविगेशन के लिए भी महंगे रीज़निंग मॉडल (
claude-3-opusया अत्यधिक Thinking वाला Sonnet) लगाना।
व्यवस्थित इंजीनियरिंग नियमों — सख्त .claudeignore स्वच्छता, प्रॉम्प्ट कैशिंग का उपयोग, सब-एजेंट कॉन्टेक्स्ट विभाजन और सटीक CLI सेटिंग्स — के माध्यम से टीमें अपने दैनिक Claude Code टोकन खर्च को 70% से 80% तक घटा सकती हैं, और साथ ही कार्यों की सफलता दर भी बढ़ा सकती हैं।
2. मात्रात्मक अर्थशास्त्र: टोकन मूल्य निर्धारण और कैशिंग संरचना
यह समझने के लिए कि टोकन कहाँ नष्ट होते हैं, Anthropic API मूल्य निर्धारण और कैशिंग स्तर (2026 मानक) देखें:
| Claude मॉडल वेरिएंट | आधार इनपुट ($/1M) | कैश राइट ($/1M) | कैश रीड ($/1M) | आउटपुट ($/1M) | SWE-bench Verified | टर्मिनल में आदर्श भूमिका |
|---|---|---|---|---|---|---|
| Claude 3.5 / 3.7 Haiku | $0.80 | $1.00 | $0.08 | $4.00 | 41.2% | सिंबल सर्च, रेगेक्स फ़िल्टरिंग, कमिट संदेश लेखन |
| Claude 3.7 Sonnet (Standard) | $3.00 | $3.75 | $0.30 | $15.00 | 70.3% | मुख्य रीफैक्टरिंग, मल्टी-फ़ाइल संपादन, टेस्ट सुधार |
| Claude 3.7 Sonnet (Extended Thinking) | $3.00 (इनपुट) | $3.75 (राइट) | $0.30 | $15.00 (थिंकिंग+आउट) | 72.8% | जटिल आर्किटेक्चरल बग, समवर्ती रेस कंडीशन्स |
| Claude 3 Opus / Opus 4.6 | $15.00 | $18.75 | $1.50 | $75.00 | 74.1% | गंभीर सुरक्षा ऑडिट, संपूर्ण सिस्टम पुनर्रचना |
लागत और टोकन में 75% की कटौती का गणित
150,000 पंक्तियों के TypeScript रिपॉजिटरी में REST API एंडपॉइंट को रीफैक्टर करने वाले 15 चरणों के एक विशिष्ट सत्र की तुलना करें:
[अव्यवस्थित प्रारंभिक सत्र]
टर्न 1: प्रोजेक्ट आर्किटेक्चर + package-lock.json + स्कीमा लोड (180,000 टोकन)
टर्न 2-5: Grep आउटपुट, बिल्ड लॉग्स, पूरी फ़ाइलें पढ़ना (संचयी 240,000 टोकन/टर्न)
कैश मिस दर: 45% (डायनामिक हेडर/टूल्स के कारण बार-बार कैश अमान्य होना)
कुल प्रोसेस्ड इनपुट टोकन: 3,250,000
वास्तविक लागत (Sonnet): ~$9.75
[अनुकूलित सत्र: .claudeignore + Prompt Cache + सब-एजेंट]
टर्न 1: संक्षिप्त AST सारांश (18,000 टोकन) -> टर्न 1 पर ही कैश हो गया
टर्न 2-5: वृद्धिशील डिफ़, Scout सब-एजेंट संक्षिप्त रिपोर्ट लौटाता है (22,000 टोकन/टर्न)
कैश हिट दर: 92% ($0.30/1M की रियायती दर पर रीड)
कुल प्रोसेस्ड इनपुट टोकन: 410,000 (भौतिक टोकन में 87.3% की कमी)
वास्तविक लागत (Sonnet): ~$0.82 (लागत में 91.5% की वास्तविक कमी)3. पहला स्तंभ: निरर्थक कॉन्टेक्स्ट को रोकने के लिए .claudeignore
किसी भी प्रोजेक्ट में सबसे अधिक प्रभावी कदम एक सख्त और व्यापक .claudeignore फ़ाइल तैयार करना है।
Claude Code डिफ़ॉल्ट रूप से .gitignore नियमों का पालन करता है, लेकिन सामान्य .gitignore फ़ाइलों में ऐसी कई विशाल फ़ाइलें छूट जाती हैं जो LLM के कॉन्टेक्स्ट विंडो को दूषित करती हैं। लॉकफाइल, प्रलेखन एसेट्स, कंपाइल की गई फ़ाइलें और मिनिफ़ाइड बंडल कभी भी मॉडल के संदर्भ में नहीं जाने चाहिए।
प्रोडक्शन-रेडी .claudeignore टेम्पलेट
इस फ़ाइल को अपने प्रोजेक्ट की रूट डायरेक्टरी में रखें:
# ==============================================================================
# .claudeignore - टोकन बचत के लिए प्रोडक्शन एक्सक्लूज़न मैट्रिक्स
# Glob और Grep के दौरान Claude Code को अनावश्यक भारी फ़ाइलें पढ़ने से रोकता है
# ==============================================================================
# पैकेज लॉकफाइल (विशाल JSON/YAML फ़ाइलें जिनका AST विश्लेषण में कोई उपयोग नहीं है)
package-lock.json
pnpm-lock.yaml
yarn.lock
bun.lockb
composer.lock
Gemfile.lock
Cargo.lock
poetry.lock
# जेनरेट किए गए बिल्ड आर्टिफैक्ट और बंडल
dist/
build/
out/
.next/
.nuxt/
.astro/
.svelte-kit/
storybook-static/
target/
*.min.js
*.min.css
*.map
# टेस्ट कवरेज रिपोर्ट, लॉग्स और प्रोफाइलिंग
coverage/
.nyc_output/
*.lcov
*.log
npm-debug.log*
yarn-debug.log*
pnpm-debug.log*
*.heapsnapshot
*.cpuprofile
# मीडिया फ़ाइलें, चित्र और बाइनरी डेटा
public/assets/
public/images/
*.png
*.jpg
*.jpeg
*.gif
*.svg
*.webp
*.avif
*.ico
*.pdf
*.zip
*.tar.gz
*.wasm
# आंतरिक दस्तावेज़ और बाहरी API विनिर्देश
docs/
*.mdx
specs/swagger/
*.postman_collection.json
# स्थानीय पर्यावरण फ़ाइलें और सुरक्षा कुंजियां
.env*
!.env.example
*.pem
*.key
*.cert
# डेटाबेस माइग्रेशन और SQL डंप फ़ाइलें
*.sql
*.dump
prisma/migrations/.claudeignore का व्यावहारिक प्रभाव
जब Claude Code प्रोजेक्ट को स्कैन करता है, तो एक गैर-अनदेखी package-lock.json (जिसमें अक्सर 25,000 से 80,000 पंक्तियां होती हैं) को एक बार पढ़ने पर ही तुरंत 120,000 से अधिक टोकन खर्च हो सकते हैं। लॉकफाइल और बिल्ड आउटपुट को बाहर करने से आपका प्रारंभिक कॉन्टेक्स्ट 180k टोकन से घटकर मात्र 15k टोकन से भी कम रह जाता है।
4. दूसरा स्तंभ: प्रॉम्प्ट कैशिंग (Prompt Caching) और 90% डिस्काउंट
Anthropic की प्रॉम्प्ट कैशिंग तकनीक इनपुट टोकन को सर्वर पर 5 मिनट तक सुरक्षित रखती है (प्रत्येक कैश हिट पर टाइमर रीसेट होता है)। कैश्ड टोकन को पढ़ने की लागत सामान्य इनपुट लागत का मात्र 10% होती है (Sonnet पर $3.00/1M के मुकाबले केवल $0.30/1M)।
+-------------------------------------------------------------------------+
| Anthropic Prompt Caching जीवन चक्र |
+-------------------------------------------------------------------------+
|
v
+-------------------------------------------------------------------------+
| [सिस्टम प्रॉम्प्ट और टूल परिभाषाएं] (स्थिर प्रीफिक्स - हमेशा कैश्ड रहता है)|
+-------------------------------------------------------------------------+
|
v
+-------------------------------------------------------------------------+
| [प्रोजेक्ट आर्किटेक्चर मैप और कोडिंग नियम] (कैश्ड चेकपॉइंट) |
+-------------------------------------------------------------------------+
|
v (कैश इनवैलिडेशन बिंदु!)
+-------------------------------------------------------------------------+
| [यूजर के डायनामिक निर्देश और टूल कॉल इतिहास] (गैर-कैश्ड भाग) |
+-------------------------------------------------------------------------+प्रॉम्प्ट कैश बनाए रखने के तीन नियम
- सिस्टम कॉन्टेक्स्ट में कभी भी डायनामिक टाइमस्टैम्प न जोड़ें:
CLAUDE.mdमें तारीखें या अस्थिर सेशन आईडी न डालें। प्रीफिक्स में एक अक्षर का बदलाव भी बाद के सभी कैश्ड टोकन को अमान्य कर देता है। - 5 मिनट की विंडो के भीतर अनुरोध भेजें: कैश का TTL 300 सेकंड है। यदि आप कोड समीक्षा करते हुए 6 मिनट रुकते हैं, तो अगले टर्न पर पूरी कैश राइट लागत ($3.75/1M) लगेगी।
- निर्देशों को स्थिर से डायनामिक के क्रम में रखें: Claude Code का आंतरिक इंजन स्थिर निर्देशों को पेलोड की शुरुआत में रखता है। सुनिश्चित करें कि
CLAUDE.mdके नियम स्थिर रहें।
5. तीसरा स्तंभ: सब-एजेंट और सब-टास्क का अलगाव
टर्मिनल कोडिंग में सबसे बड़ा नुकसान मोनोलिथिक सेशन (एकल लंबा सत्र) के कारण होता है। इसमें डेवलपर एक ही संवाद में Claude से बग ढूंढने, टेस्ट लिखने, कोड रीफैक्टर करने, इंटीग्रेशन टेस्ट चलाने और प्रलेखन तैयार करने के लिए कहता है।
12वें टर्न तक पहुँचते-पहुँचते कॉन्टेक्स्ट विंडो में असफल टेस्ट लॉग्स, कंपाइलर चेतावनियों और पुराने कोड के सैकड़ों अंश भर जाते हैं। इसके बाद का हर नया प्रश्न इस पूरे भारी कचरे को API पर दोबारा भेजता है।
दो-स्तरीय एजेंट आर्किटेक्चर: Scout और Worker
कोड की खोजबीन को वास्तविक कोड संपादन से अलग करें:
[उपयोगकर्ता का अनुरोध]
|
v
+---------------------------------------------+
| स्तर 1: रीड-ओनली Scout सब-एजेंट |
| - claude-3-5-haiku या हल्के मॉडल पर चलता है|
| - Glob, Grep और पंक्ति-सीमा पठन करता है |
| - 500,000 टोकन को 2KB सारांश में समेटता है |
+---------------------------------------------+
|
v (संक्षिप्त कॉन्टेक्स्ट का हस्तांतरण)
+---------------------------------------------+
| स्तर 2: प्राथमिक निष्पादन एजेंट (Worker) |
| - claude-3-7-sonnet पर चलता है |
| - सटीक फ़ाइल पथ और AST सिंबल प्राप्त करता है|
| - पंक्ति-आधारित सटीक पैच लागू करता है |
+---------------------------------------------+Claude Code में कार्यों को अलग करने का तरीका
जटिल कार्यों को अलग-अलग चरणों में विभाजित करें:
# गलत तरीका: एक ही सत्र में कॉन्टेक्स्ट का भारी विस्तार
claude "पुराने ऑथेंटिकेशन वाले सभी एंडपॉइंट ढूंढें, OAuth2 पर माइग्रेट करें, टेस्ट ठीक करें और प्रलेखन लिखें"
# सही तरीका: पहले पृथक खोजबीन -> फिर सटीक संपादन
# चरण 1: कम टोकन में खोजबीन
claude --model claude-3-5-haiku -p "केवल उन फ़ाइल पथों और पंक्ति नंबरों की सूची JSON में दें जहाँ पुराना ऑथ मिडलवेयर है।" > auth-audit.json
# चरण 2: स्वच्छ कॉन्टेक्स्ट में सटीक बदलाव
claude --model claude-3-7-sonnet "auth-audit.json में सूचीबद्ध एंडपॉइंट्स को OAuth2 में बदलें। किसी अन्य फ़ाइल को न छुएं।"6. चौथा स्तंभ: मॉडल चयन — कौन सा Claude मॉडल कम टोकन खर्च करता है?
एक ही कार्य के लिए अलग-अलग Claude मॉडल भिन्न-भिन्न टोकन खर्च करते हैं:
- Thinking बजट: विस्तारित चिंतन (Extended Thinking) वाले मॉडल आंतरिक विचार प्रक्रिया में हजारों टोकन उत्पन्न करते हैं, जिनका बिल आउटपुट दर ($15.00/1M) पर आता है।
- टूल कॉल में अनावश्यक विस्तार: कुछ मॉडल टूल कॉल से पहले लंबी व्याख्या देते हैं, जिससे टोकन व्यर्थ होते हैं।
- खोज दक्षता: कुशल मॉडल 1-2 सटीक grep कॉल्स से आवश्यक कोड ढूंढ लेते हैं, जबकि कम सक्षम मॉडल पूरी फ़ाइलों को पढ़ने लगते हैं।
कार्यों के अनुसार टोकन खपत की तुलना
| कार्य का प्रकार | Claude 3.5 Haiku | Claude 3.7 Sonnet (Normal) | Claude 3.7 Sonnet (8k Thinking) | Claude 3 Opus |
|---|---|---|---|---|
| प्रोजेक्ट में सिंबल खोजना | 12k टोकन / $0.01 | 14k टोकन / $0.04 | 24k टोकन / $0.18 | 18k टोकन / $0.27 |
| एक फ़ंक्शन में बग सुधार | 28k टोकन / $0.03 | 22k टोकन / $0.07 | 35k टोकन / $0.24 | 30k टोकन / $0.45 |
| मल्टी-फ़ाइल रीफैक्टरिंग | विफलता दर अधिक | 140k टोकन / $0.48 | 190k टोकन / $1.25 | 220k टोकन / $3.30 |
| जटिल रेस कंडीशन समस्या | हल नहीं कर पाता | 320k टोकन (असफल) | 240k टोकन (सफल) / $1.60 | 280k टोकन / $4.20 |
मॉडल चयन रणनीति
- डिफ़ॉल्ट मॉडल: दैनिक कार्यों के 80% भाग के लिए सामान्य
claude-3-7-sonnetका उपयोग करें। - खोज और स्क्रिप्टिंग: फ़ाइल ढूंढने, रेगेक्स बनाने और टेस्ट लॉग्स की जांच के लिए
claude-3-5-haikuअपनाएं। - विस्तारित चिंतन का सीमित उपयोग: केवल उन कठिन एल्गोरिदम या कंपाइलर त्रुटियों के लिए Thinking ऑन करें जो पहले प्रयास में हल न हों।
7. Claude Code की उन्नत सेटिंग्स और .claude/config.json
आप ~/.claude.json या प्रोजेक्ट के .claude/config.json के माध्यम से व्यवहार को नियंत्रित कर सकते हैं।
उच्च दक्षता वाली .claude/config.json सेटिंग्स
{
"$schema": "https://json.schemastore.org/claude-code-config.json",
"model": "claude-3-7-sonnet",
"maxThinkingTokens": 2048,
"autoCompactContext": true,
"contextCompactionThreshold": 0.65,
"allowedTools": [
"Edit",
"Bash",
"Glob",
"Grep",
"Read"
],
"toolLimits": {
"bashOutputMaxLines": 150,
"readFileMaxLines": 300
},
"enableTelemetry": false
}मुख्य पैरामीटर्स का विश्लेषण
maxThinkingTokens: 2048: सोचने के बजट पर सीमा लगाता है ताकि सामान्य कार्यों पर भी प्रति टर्न 8k से 16k टोकन ($0.12 - $0.24) बर्बाद न हों।autoCompactContext: true: जब संदर्भ 65% भर जाता है (contextCompactionThreshold: 0.65), तो यह स्वचालित रूप से पुराने वार्तालाप को संक्षिप्त सारांश में बदल देता है।bashOutputMaxLines: 150: टेस्ट या पैकेज इंस्टॉलेशन के दौरान 5,000 पंक्तियों के लंबे लॉग्स को सीधे कॉन्टेक्स्ट में जाने से रोकता है।
8. टोकन बचाने वाले टर्मिनल प्रॉम्प्टिंग तरीके
प्रॉम्प्ट लिखने की आपकी शैली सत्र के कुल टोकन खर्च को 40% तक प्रभावित करती है:
तरीका 1: विशिष्ट पंक्तियों को पढ़ने का निर्देश दें
पूरी फ़ाइल पढ़ने के बजाय, केवल आवश्यक पंक्तियों को देखने को कहें:
# गलत: 1,800 पंक्तियां (लगभग 14,000 टोकन) पढ़ता है
"src/auth/session.ts पढ़ें और देखें कि टोकन सत्यापन क्यों विफल हो रहा है"
# सही: केवल 60 पंक्तियां (लगभग 450 टोकन) पढ़ता है
"src/auth/session.ts की पंक्ति 120-180 की जांच करें जहाँ verifyJwt() फ़ंक्शन है"तरीका 2: कमांड आउटपुट को संक्षिप्त रखें
टेस्ट या कंपाइलेशन चलाते समय आउटपुट को सीमित करें:
# गलत: सफल टेस्ट के हजारों लॉग्स कॉन्टेक्स्ट में उड़ेल देता है
"npm test चलाएं और एरर ठीक करें"
# सही: आउटपुट को नियंत्रित करता है
"npm test -- --reporter=dot चलाएं या grep से केवल एरर निकालें। सफल टेस्ट के लॉग न दिखाएं।"तरीका 3: कॉन्टेक्स्ट की समय पर सफाई (/compact और /clear)
Claude Code के इन-बिल्ट कमांड का उपयोग करें:
/compact: तुरंत वर्तमान वार्तालाप को संक्षिप्त तकनीकी सारांश में बदल देता है।/clear: बिना टर्मिनल बंद किए संदर्भ को पूरी तरह साफ करता है ताकि नया कार्य नए सिरे से शुरू हो सके।
9. टोकन बचत रणनीतियों की तुलनात्मक तालिका
| रणनीति | औसत टोकन बचत | क्रियान्वयन कठिनाई | कोड गुणवत्ता जोखिम | कार्य प्रणाली |
|---|---|---|---|---|
कड़ा .claudeignore |
40% – 60% | कम (5 मिनट) | शून्य | लॉकफाइल और बिल्ड फ़ोल्डर रोकता है |
कॉन्टेक्स्ट संक्षेपण (/compact) |
30% – 50% | तुरंत (कमांड) | बहुत कम | पुराने शेल लॉग्स और कोड संस्करण हटाता है |
| सब-एजेंट स्काउटिंग | 35% – 55% | मध्यम | न्यूनतम | पढ़ने और संपादन के कार्यों को अलग करता है |
| Thinking बजट सीमा | 20% – 35% | कम (कॉन्फ़िग) | कम-मध्यम | सामान्य कार्यों में अत्यधिक विचार रोकता है |
| पंक्ति-आधारित पैचिंग | 15% – 25% | कम (नियम) | कम | फ़ाइल को दोबारा लिखने के बजाय डिफ़ लगाता है |
| प्रॉम्प्ट कैश संरेखण | 10% – 20% (लागत) | मध्यम | शून्य | स्थिर प्रीफिक्स से 90% छूट दिलाता है |
10. निष्कर्ष और 5-चरणीय चेकलिस्ट
Claude Code में टोकन का उपयोग 75% घटाने से कोड की गुणवत्ता में कोई कमी नहीं आती। बल्कि, स्वच्छ और केंद्रित कॉन्टेक्स्ट से मॉडल का भटकाव रुकता है और वह अधिक सटीक समाधान प्रदान करता है।
5-चरणीय चेकलिस्ट:
- [ ]
.claudeignoreजोड़ें: प्रोडक्शन टेम्पलेट को प्रोजेक्ट रूट में डालें और सभी लॉकफाइल व बिल्ड फ़ोल्डर ब्लॉक करें। - [ ]
config.jsonट्यून करें: Thinking टोकन सीमा2048रखें औरautoCompactContextको0.65पर सक्रिय करें। - [ ] कार्य के अनुसार मॉडल चुनें: कोडिंग के लिए
claude-3-7-sonnet, सर्च के लिएclaude-3-5-haikuका उपयोग करें। - [ ] कंसोल आउटपुट सीमित करें: टेस्ट रनर में
--reporter=minया grep का प्रयोग कर टर्मिनल आउटपुट को 100 पंक्तियों के भीतर रखें। - [ ] नियमित रूप से संदर्भ साफ करें: नए कार्य से पहले
/compactया/clearचलाकर Context Rot को रोकें।
इन तौर-तरीकों को अपनाकर आप अपने मासिक API खर्चों को बेहद कम रखते हुए स्वायत्त AI कोडिंग का पूरा लाभ उठा सकते हैं।