BroadRouter

प्रॉम्प्ट टोकन कैसे घटाएँ: सिस्टम प्रॉम्प्ट, टूल, डेटा की मापी कटौती

BroadNet Inference टीम · 7 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

पहले मापें: हर कॉल के prompt_tokens लॉग करें, सबसे बड़ा हिस्सा ढूँढें, और मॉडल के टोकनाइज़र से पहले-बाद की तुलना करें। पाँच टोकनाइज़र पर, लंबा-चौड़ा सिस्टम प्रॉम्प्ट छोटा करने से 68 से 71% बचे और CSV ने मिनिफ़ाइड JSON से 31 से 41% कम टोकन लिए। तीन मॉडल पर, छोटे किए सिस्टम प्रॉम्प्ट के साथ 10 लंबे टूल की जगह 3 छोटे टूल देने से पूरा रेंडर हुआ अनुरोध लगभग 65 से 71% घटा।

छोटे प्रॉम्प्ट की लागत कम होती है, काम के लिए कॉन्टेक्स्ट विंडो में ज़्यादा जगह बचती है, और आम तौर पर पहला टोकन जल्दी आता है। पर “प्रॉम्प्ट छोटा करो” एक अस्पष्ट सलाह है। यह पोस्ट एक असली जैसे सपोर्ट-बॉट प्रॉम्प्ट पर आम कटौतियों को मापती है, चार ओपन मॉडलों के असली टोकनाइज़र और OpenAI के o200k_base से, ताकि आप देख सकें कि कौन-से बदलाव आपके समय के लायक हैं।

अगर आप कोडिंग एजेंट चलाते हैं, तो एजेंट का टोकन बजट उस लूप को कवर करता है। यह पोस्ट ऐप्लिकेशन प्रॉम्प्ट के बारे में है: चैटबॉट, क्लासिफ़ायर और एक्सट्रैक्शन जॉब।

हमने कैसे मापा?

नीचे की सभी गिनतियाँ हमारी हैं, 15 नवंबर 2026 को की गईं:

  • टोकनाइज़र। DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B और Google के Gemma 4 26B A4B की आधिकारिक tokenizer.json फ़ाइलें, हर एक तय Hugging Face रिविज़न पर (स्रोत देखें), Hugging Face tokenizers 0.23.3 से लोड की गईं। साथ में GPT मॉडलों से तुलना के लिए tiktoken 0.14.0 से o200k_base। स्पेशल टोकन नहीं जोड़े गए।
  • रेंडर हुए प्रॉम्प्ट। DeepSeek, GLM और Qwen के लिए हमने पूरे अनुरोध को हर मॉडल के प्रकाशित chat_template.jinja (Jinja2 सैंडबॉक्स) से भी रेंडर किया, सिस्टम प्रॉम्प्ट, टूल, इतिहास और सवाल के साथ, और नतीजा गिना। यह उसके क़रीब है जो सर्वर टोकनाइज़ करता है, पर प्रोवाइडर अलग टेम्पलेट इस्तेमाल कर सकता है, इसलिए API के usage.prompt_tokens को अंतिम मानें।
  • टेक्स्ट। एक काल्पनिक टेलीकॉम का सिंथेटिक सपोर्ट बॉट: 261 शब्दों का सिस्टम प्रॉम्प्ट, 10 टूल, 8 few-shot उदाहरण, 40 ऑर्डर पंक्तियाँ, 20 टर्न का इतिहास और 31 शब्दों का अरबी पैराग्राफ़। एक प्रॉम्प्ट एक डेटा पॉइंट है। आपकी बचत अलग होगी; तरीक़ा वही रहेगा।

BroadNet का Gemma 4 VL 26B, Google के मॉडल पर आधारित है, इसलिए उसकी गिनती एक अनुमान है। बाक़ी मॉडलों की गिनती उनकी अपनी फ़ाइलों से है।

कौन-सी कटौती सबसे ज़्यादा टोकन बचाती है?

कच्चा टेक्स्ट, पहले → बाद, बचत के हिस्से के साथ:

बदलाव DeepSeek V4.1 Flash GLM 5.3 Qwen3.8 27B Gemma 4 GPT o200k
सिस्टम प्रॉम्प्ट: 261 शब्द → 66 शब्द 295 → 88 (70%) 294 → 89 (70%) 297 → 95 (68%) 297 → 96 (68%) 293 → 86 (71%)
Few-shot: 8 उदाहरण → 3 157 → 69 (56%) 157 → 69 (56%) 156 → 71 (54%) 156 → 71 (54%) 152 → 69 (55%)
40 पंक्तियाँ: इंडेंट किया JSON → मिनिफ़ाइड JSON 2,446 → 1,606 (34%) 2,460 → 1,581 (36%) 3,180 → 1,980 (38%) 3,210 → 2,010 (37%) 2,446 → 1,567 (36%)
40 पंक्तियाँ: मिनिफ़ाइड JSON → CSV 1,606 → 948 (41%) 1,581 → 960 (39%) 1,980 → 1,359 (31%) 2,010 → 1,382 (31%) 1,567 → 946 (40%)
10 टूल: लंबे → छोटे विवरण 1,224 → 806 (34%) 1,214 → 797 (34%) 1,225 → 806 (34%) 1,252 → 827 (34%) 1,202 → 796 (34%)
10 लंबे टूल → 3 छोटे 1,224 → 258 (79%) 1,214 → 257 (79%) 1,225 → 266 (78%) 1,252 → 276 (78%) 1,202 → 255 (79%)
अरबी पैराग्राफ़: पूरी हरकात → सादा 193 → 74 (62%) 267 → 78 (71%) 151 → 62 (59%) 180 → 64 (64%) 218 → 62 (72%)

अंग्रेज़ी गद्य के लिए प्रतिशत सभी टोकनाइज़र पर मिलते-जुलते हैं, इसलिए जो कटौती एक मॉडल पर मदद करती है, वह दूसरों पर भी करती है। दो पंक्तियाँ यह पैटर्न तोड़ती हैं। ऑर्डर डेटा हर फ़ॉर्मैट में Qwen और Gemma पर DeepSeek और GLM से 23 से 46% ज़्यादा टोकन का पड़ा, क्योंकि उनके टोकनाइज़र संख्याओं को एक-एक अंक में तोड़ते हैं: 100200 Qwen पर 6 टोकन है और DeepSeek पर 2। और अरबी हरकात कुछ टोकनाइज़र पर दूसरों से कहीं ज़्यादा भारी पड़ती है।

पूरा अनुरोध कैसा दिखता है?

कच्चा टेक्स्ट चैट टेम्पलेट को छोड़ देता है। हर मॉडल के अपने टेम्पलेट से रेंडर करके, ग्राहक के एक ही सवाल के साथ, मापा गया पूरा प्रॉम्प्ट:

अनुरोध DeepSeek V4.1 Flash GLM 5.3 Qwen3.8 27B
A. लंबा सिस्टम प्रॉम्प्ट + 10 लंबे टूल 1,677 1,535 1,797
B. छोटा किया सिस्टम प्रॉम्प्ट + 10 छोटे टूल 1,052 913 1,176
C. छोटा किया सिस्टम प्रॉम्प्ट + 3 छोटे टूल 574 443 636
D. छोटा किया सिस्टम प्रॉम्प्ट, कोई टूल नहीं 136 121 174
C + पिछले 20 टर्न पूरे 2,374 2,243 2,693
C + 3 लाइन का सारांश + आख़िरी 4 टर्न 979 849 1,103

A से C पर जाने से हर अनुरोध का लगभग 65 से 71% घटा (Qwen पर 64.6%, GLM पर 71.1%)। इसका ज़्यादातर हिस्सा टूल से आया। लंबे सिस्टम प्रॉम्प्ट के साथ रेंडर करने पर, 10 लंबे टूल ने DeepSeek पर 1,334, GLM पर 1,209 और Qwen पर 1,421 टोकन जोड़े; C के 3 छोटे टूल ने D के ऊपर 322 से 462 जोड़े। टूल कॉलिंग स्कीमा हर अनुरोध के साथ जाते हैं, मॉडल उन्हें इस्तेमाल करे या न करे।

बड़े वॉल्यूम पर यह जुड़ता जाता है। Qwen3.8 27B पर A से C हर अनुरोध पर 1,161 टोकन बचाता है। 100,000 अनुरोध प्रति माह पर यह लगभग 11.6 करोड़ (116M) इनपुट टोकन है, यानी स्टैंडर्ड इनपुट कीमत पर हर महीने 116 × $0.175।

सिस्टम प्रॉम्प्ट को बिना तोड़े छोटा कैसे करें?

हमारे 261 शब्दों और 66 शब्दों वाले प्रॉम्प्ट में वही सात नियम हैं। सारी कटौतियाँ एक ही तरह की थीं:

  1. मॉडल से शिष्टाचार हटाएँ। “It is very important that you always remain polite and courteous at all times” (अनुवाद: यह बहुत ज़रूरी है कि आप हर समय विनम्र और शिष्ट रहें) पूरी तरह हट गया: रोल वाली लाइन से यह अपने आप समझ आता है।
  2. हर लाइन पर एक नियम। “Please make sure that you always…” (अनुवाद: कृपया सुनिश्चित करें कि आप हमेशा…) वाले वाक्यों की जगह बुलेट।
  3. दोहराव मिलाएँ। भाषा के बारे में तीन वाक्य बन गए “Reply in the customer’s language (Arabic or English), briefly.” (अनुवाद: ग्राहक की भाषा (अरबी या अंग्रेज़ी) में, संक्षेप में जवाब दें।)
  4. दोहराए गए डिफ़ॉल्ट हटाएँ। “Remember to always be helpful!” (अनुवाद: हमेशा मददगार रहना याद रखें!) कुछ नहीं बदलता।

फिर टेस्ट करें। एक छोटा प्रॉम्प्ट जो कोई नियम खो देता है, बचत से ज़्यादा नुक़सान करता है। दोनों वर्ज़न को वही 50 से 100 असली इनपुट पर चलाएँ और तुलना करें, जैसे बदलने से पहले LLM का मूल्यांकन में बताया गया है।

कितने few-shot उदाहरण चाहिए?

ज़्यादातर प्रॉम्प्ट जितने रखते हैं, उससे कम। हर few-shot उदाहरण का भुगतान हर कॉल पर होता है। वे रखें जो ऐसी ग़लती ठीक करते हैं जो मॉडल उनके बिना करता है, जैसे अरबी क्लासिफ़ायर के लिए बोली का उदाहरण, और वे हटा दें जिन्हें मॉडल पहले से सही करता है। हमारी 8 → 3 कटौती से उदाहरणों वाले हिस्से का 54 से 56% बचा। आपके काम के लिए 3 काफ़ी हैं या नहीं, यह सटीकता का सवाल है, टोकन का नहीं, इसलिए इसे अपने टेस्ट सेट पर जाँचें।

क्या टूल, डेटा और इतिहास अलग तरह से भेजने चाहिए?

टूल। सिर्फ़ वे टूल भेजें जो मौजूदा स्टेप इस्तेमाल कर सकता है। बिलिंग वाले सवाल को get_account, get_bill और create_ticket चाहिए, order_esim नहीं। विवरण को उतना छोटा करें जितना मॉडल को टूल चुनने और भरने के लिए चाहिए। यहाँ इंडेंटेशन मायने नहीं रखता: हमने जितने टेम्पलेट रेंडर किए, सभी tools ऐरे को tojson से दोबारा सीरियलाइज़ करते हैं, इसलिए सुंदर फ़ॉर्मैट वाला tools ऐरे मिनिफ़ाइड जितना ही पड़ता है।

संदेशों में डेटा। जो डेटा आप संदेश में पेस्ट करते हैं, वह वैसा ही भेजा जाता है जैसा लिखा है। कम से कम JSON को मिनिफ़ाई करें। सपाट रिकॉर्ड के लिए CSV या TSV दोहराई गई keys हटा देता है: हमारे टेस्ट में मिनिफ़ाइड JSON से 31 से 41% कम टोकन। नेस्टेड डेटा JSON ही रहे। जाँचें कि मॉडल अब भी कॉलम सही पढ़ता है।

इतिहास। हर पिछला टर्न दोबारा भेजा जाता है। 16 पुराने टर्न की जगह तीन लाइन का सारांश रखने और आख़िरी चार टर्न हूबहू रखने से Qwen का प्रॉम्प्ट 2,693 से 1,103 टोकन पर आ गया। सारांश वह ब्योरा छोड़ देता है जिसका यूज़र बाद में ज़िक्र कर सकता है, और उसे दोबारा लिखने से प्रीफ़िक्स बदलता है, जिससे कैशिंग टूटती है। लंबे चलने वाले एजेंट का कॉन्टेक्स्ट प्रबंधन बताता है कि कब छोटा करें।

अरबी हरकात। ज़्यादातर अरबी छोटे स्वरों (हरकात) के बिना लिखी जाती है। अगर आपका इनपुट पूरी हरकात वाला है, किसी शब्दकोश, पाठ्यपुस्तक या धार्मिक स्रोत से, तो चिह्न (U+064B से U+0652) हटाने से हमारा पैराग्राफ़ 59 से 72% घटा। जब काम उन पर निर्भर हो, जैसे पढ़ाई या कविता, तो उन्हें रखें। अरबी टेक्स्ट नॉर्मलाइज़ेशन उन दूसरे अक्षरों को कवर करता है जिन्हें नॉर्मलाइज़ करना फ़ायदेमंद है, और अरबी में प्रति शब्द टोकन अंग्रेज़ी से बड़े फ़ासले को।

कैशिंग कहाँ फ़िट होती है?

कैशिंग प्रॉम्प्ट को छोटा नहीं करती। यह दोहराए गए हिस्से को सस्ता बनाती है। OpenAI की कैशिंग गाइड कहती है कि “the entire rendered prefix” (अनुवाद: पूरा रेंडर हुआ प्रीफ़िक्स) मेल खाना चाहिए, और स्थिर निर्देश पहले रखने की सलाह देती है। BroadNet का प्राइसिंग पेज कैश्ड इनपुट को “usually the repeated start of recent requests, such as a long system prompt” (अनुवाद: आम तौर पर हाल के अनुरोधों की दोहराई गई शुरुआत, जैसे लंबा सिस्टम प्रॉम्प्ट) बताता है, जिसमें कुछ सेट नहीं करना पड़ता, और उसका डॉक्यूमेंटेशन हिट usage.prompt_tokens_details.cached_tokens में रिपोर्ट करता है।

इसलिए क्रम यह है: पहले छोटा करें, फिर छोटे किए प्रीफ़िक्स को स्थिर बनाएँ। सिस्टम प्रॉम्प्ट और टूल पहले, हर कॉल पर बाइट-दर-बाइट एक जैसे; उसके बाद इतिहास, सिर्फ़ आगे जुड़ता हुआ; नया संदेश आख़िर में। Qwen3.8 27B पर कैश्ड इनपुट $0.0435 प्रति 1M है, जबकि नया $0.175। कैशिंग के लिए प्रॉम्प्ट का ढाँचा में लेआउट और एक टेस्ट है जो साबित करता है कि प्रीफ़िक्स दोबारा इस्तेमाल हुआ। कैश्ड टोकन फिर भी कॉन्टेक्स्ट विंडो में गिने जाते हैं।

अपना प्रॉम्प्ट कैसे मापें?

बिल से शुरू करें। एक दिन तक हर कॉल-साइट के usage.prompt_tokens लॉग करें और सबसे बड़ा ढूँढें। फिर इस स्क्रिप्ट से लोकल में वर्ज़न की तुलना करें, जो दो फ़ाइलों के पहले और बाद के टोकन गिनकर दिखाती है:

# pip install tokenizers tiktoken huggingface_hub
import json, sys
import tiktoken
from huggingface_hub import hf_hub_download
from tokenizers import Tokenizer

def hf(repo, rev):
    return Tokenizer.from_file(hf_hub_download(repo, "tokenizer.json", revision=rev))

COUNTERS = {
    "Qwen3.8 27B": hf("Qwen/Qwen3.8-27B", "37561816e66b5b9153b1b64c10968c18c1e6f4a0").encode,
    "GPT o200k": tiktoken.get_encoding("o200k_base").encode,
}

def n(enc, text):
    out = enc(text)
    return len(out.ids if hasattr(out, "ids") else out)

def diff(before, after):
    for name, enc in COUNTERS.items():
        a, b = n(enc, before), n(enc, after)
        print(f"{name:12} {a:6} -> {b:6}  saved {a - b} ({100 * (a - b) / a:.0f}%)")

if __name__ == "__main__":
    diff(open(sys.argv[1], encoding="utf-8").read(), open(sys.argv[2], encoding="utf-8").read())

हमारे दोनों सिस्टम प्रॉम्प्ट पर चलाने से यह छपा:

Qwen3.8 27B     297 ->     95  saved 202 (68%)
GPT o200k       293 ->     86  saved 207 (71%)

चारों की तुलना के लिए स्रोतों की सूची से दूसरे मॉडलों की रिपॉज़िटरी जोड़ें। ब्राउज़र में जल्दी जाँच के लिए, प्रॉम्प्ट टोकन डिफ़ दो वर्ज़न की आमने-सामने तुलना करता है, और टोकन काउंटर एक को गिनता है। डिप्लॉय के बाद, बचत की पुष्टि usage.prompt_tokens में करें, जिसमें टेम्पलेट शामिल है।

BroadNet Inference कहाँ फ़िट होता है

BroadRouter, BroadNet की साइट है। BroadNet Inference प्रॉम्प्ट टोकन हर मॉडल की इनपुट कीमत पर बिल करता है, और जिस मॉडल की कैश्ड कीमत है, उस पर दोहराए गए प्रीफ़िक्स कैश से कैश्ड कीमत पर पढ़ता है, इसलिए छोटे प्रॉम्प्ट और स्थिर प्रीफ़िक्स, दोनों बिल घटाते हैं। Gemma 4 VL 26B का कॉन्टेक्स्ट 32,768 टोकन है, जहाँ छोटा करना लागत के साथ-साथ फ़िट होने के लिए भी मायने रखता है। DeepSeek V4.1 Flash के प्लान पर कोई टोकन मीटर नहीं है, पर 1,048,576 टोकन का कॉन्टेक्स्ट फिर भी लागू है, और छोटा प्रॉम्प्ट फिर भी जल्दी जवाब देता है। हर अनुरोध के बाद प्रॉम्प्ट नहीं रखे जाते।

अक्सर पूछे जाने वाले सवाल

अपने प्रॉम्प्ट में टोकन की संख्या कैसे कम करूँ?

पहले मापें: usage.prompt_tokens लॉग करें और सबसे बड़ा हिस्सा ढूँढें। फिर, हमारी माप में सबसे ज़्यादा बचत के क्रम में: सिर्फ़ उस स्टेप के ज़रूरी टूल भेजें, टूल और सिस्टम प्रॉम्प्ट के शब्द छोटे करें, टेबल JSON की जगह CSV में भेजें, few-shot उदाहरण सिर्फ़ वे रखें जो नतीजे बदलते हैं, और पुराने चैट टर्न का सारांश बनाएँ।

क्या सुंदर फ़ॉर्मैट (इंडेंट) वाला JSON ज़्यादा टोकन लेता है?

हाँ। हमारे टेस्ट में, इंडेंट किए JSON की 40 पंक्तियों को मिनिफ़ाई करने से टोकनाइज़र के हिसाब से 34 से 38% टोकन बचे, और CSV में भेजने से 57 से 61%। दूसरी तरह से कहें तो इंडेंट किए JSON ने मिनिफ़ाइड JSON से 52 से 61% और CSV से 132 से 159% ज़्यादा टोकन लिए। टूल स्कीमा अपवाद हैं: चैट टेम्पलेट उन्हें दोबारा सीरियलाइज़ करते हैं, इसलिए आपके tools ऐरे का इंडेंटेशन मॉडल तक नहीं पहुँचता।

टूल डेफ़िनिशन कितने टोकन लेती हैं?

यह शब्दों और मॉडल के टेम्पलेट पर निर्भर है। लंबे विवरण वाले हमारे 10 टूल ने DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B पर रेंडर हुए प्रॉम्प्ट में लगभग 1,200 से 1,400 टोकन जोड़े। छोटे विवरण वाले तीन टूल ने लगभग 320 से 460 जोड़े।

क्या अरबी हरकात (डायक्रिटिक्स) से टोकन बढ़ते हैं?

बहुत। 31 शब्दों का एक MSA पैराग्राफ़ पाँच टोकनाइज़र पर बिना हरकात के 62 से 78 टोकन और पूरी हरकात के साथ 151 से 267 टोकन का था। ज़्यादातर अरबी टेक्स्ट बिना हरकात के लिखा जाता है, इसलिए जब तक काम (जैसे कविता या पढ़ाई) को इनकी ज़रूरत न हो, इनपुट से इन्हें हटा दें।

क्या प्रॉम्प्ट कैशिंग, प्रॉम्प्ट छोटा करने से बेहतर है?

दोनों साथ काम करते हैं। कैशिंग दोहराए गए प्रीफ़िक्स को सस्ता बनाती है, पर वह फिर भी कॉन्टेक्स्ट विंडो में गिना जाता है और उसकी भी एक कीमत है। पहले छोटा करें, फिर छोटे किए प्रीफ़िक्स को हर अनुरोध की शुरुआत में बाइट-दर-बाइट एक जैसा रखें ताकि वह कैश से पढ़ा जा सके।

मेरी टोकन गिनती API के prompt_tokens से अलग क्यों है?

API रेंडर हुआ प्रॉम्प्ट गिनता है: चैट टेम्पलेट में लिपटे आपके संदेश, और टेम्पलेट के अपने फ़ॉर्मैट में टूल स्कीमा। आपके कच्चे टेक्स्ट पर चलाया गया टोकनाइज़र यह छोड़ देता है। वर्ज़न की तुलना के लिए टोकनाइज़र और बिल के लिए usage.prompt_tokens इस्तेमाल करें।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें

स्रोत