BroadRouter

प्रॉम्प्ट को कैसे बनाएँ ताकि प्रीफ़िक्स कैश हो

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

हर अनुरोध को सबसे स्थिर से सबसे कम स्थिर क्रम में रखें: सिस्टम प्रॉम्प्ट, टूल डेफ़िनिशन, रेफ़रंस डॉक्यूमेंट, बातचीत का इतिहास, फिर नया संदेश। हर परत को कॉल के बीच बाइट-दर-बाइट एक जैसा रखें: ऊपर कोई टाइमस्टैम्प या ID नहीं, टूल क्रम में, JSON एक तय तरीक़े से सीरियलाइज़, और इतिहास में सिर्फ़ जोड़ना। फिर cached_tokens मापकर पुष्टि करें कि प्रीफ़िक्स सच में दोबारा इस्तेमाल हो रहा है।

कैश्ड इनपुट टोकन सस्ते होते हैं, और BroadNet Inference पर DeepSeek V4.1 Flash उन्हें $0.175 की जगह $0.0055 प्रति 1M पर बिल करता है। कैश्ड टोकन की व्याख्या कीमत और usage फ़ील्ड पढ़ने का तरीक़ा बताती है। यह पोस्ट डिज़ाइन के काम के बारे में है: प्रॉम्प्ट को कैसे सजाएँ कि कैश सच में हिट हो, और इसे कैसे साबित करें।

प्रॉम्प्ट का क्रम कैश हिट रेट क्यों तय करता है?

हर बड़ा प्रोवाइडर प्रीफ़िक्स के आधार पर कैश करता है। OpenAI की गाइड कहती है कि दोबारा इस्तेमाल के लिए पूरा रेंडर हुआ प्रीफ़िक्स मेल खाना चाहिए। DeepSeek का डॉक्यूमेंटेशन यही नियम बताता है: अनुरोध तभी हिट होता है जब वह सहेजे गए प्रीफ़िक्स से पूरी तरह मेल खाए, और जो बीच में अलग हो जाए, वह हिट नहीं होता। Anthropic अपना कैश टूल, सिस्टम, संदेश के क्रम में बनाता है।

अंदर से सर्वर उस प्रीफ़िक्स के लिए बनाया गया KV कैश दोबारा इस्तेमाल करता है। इसलिए कैश पहले टोकन से एक सीधी रेखा है। पिछली कॉल से अलग पहला बाइट दोबारा इस्तेमाल होने वाले हिस्से को ख़त्म कर देता है। 50,000 टोकन के प्रॉम्प्ट के ऊपर एक लाइन का टाइमस्टैम्प आपसे सभी 50,000 टोकन पूरी कीमत पर वसूल करवाता है।

परतों का सही क्रम क्या है?

परत कब बदलती है उदाहरण नियम
1. सिस्टम प्रॉम्प्ट हर डिप्लॉय पर रोल, नियम, आउटपुट फ़ॉर्मैट कोई तारीख़, ID, यूज़र नाम नहीं
2. टूल डेफ़िनिशन हर डिप्लॉय पर फ़ंक्शन स्कीमा क्रमबद्ध, तय तरीक़े वाला JSON
3. रेफ़रंस सामग्री हर सेशन या टास्क पर रिपॉज़िटरी फ़ाइलें, कॉन्ट्रैक्ट, प्रोडक्ट डॉक्यूमेंट तय क्रम, स्थिर लेबल
4. बातचीत का इतिहास हर टर्न पर, सिर्फ़ जोड़ना यूज़र और असिस्टेंट के पिछले टर्न कभी बदलें नहीं; सिर्फ़ जोड़ें
5. नया संदेश हर कॉल पर सवाल, और ज़रूरत हो तो मौजूदा समय बदलने वाला डेटा यहाँ जाता है

जो कुछ भी बदलता है, वह परत 5 में जाता है: आज की तारीख़, यूज़र का लोकेल, अनुरोध ID, हर सवाल पर अलग रिट्रीव किए गए अंश।

क्या चीज़ें बिना पता चले प्रीफ़िक्स तोड़ देती हैं?

  1. डिक्शनरी का क्रम। फ़्रेमवर्क अक्सर tools ऐरे को किसी dict या रजिस्ट्री से बनाते हैं। अगर प्लगइन अलग क्रम में लोड हों, तो बाइट बदल जाते हैं।
  2. JSON फ़ॉर्मैटिंग। json.dumps(x) और json.dumps(x, indent=2) अलग प्रीफ़िक्स हैं। अलग key क्रम वाले दो सीरियलाइज़र भी।
  3. टेम्पलेट का व्हाइटस्पेस। आख़िर में एक स्पेस, या एक कोड पाथ से \r\n और दूसरे से \n।
  4. बदलती टूल सूची। जिन टूल को यूज़र इस्तेमाल नहीं कर सकता, उन्हें हटाने से प्रीफ़िक्स बदलता है। OpenAI की गाइड डेफ़िनिशन स्थिर रखने और tool_choice या allowed-tools सेटिंग से इस्तेमाल सीमित करने की सलाह देती है।
  5. इतिहास का उसी जगह सारांश। पुराने टर्न को सारांश में दोबारा लिखने से सिस्टम प्रॉम्प्ट के बाद का सब कुछ रीसेट हो जाता है। सारांश कभी-कभार और बड़े क़दमों में बनाएँ।
  6. निर्देशों से पहले रिट्रीवल। सिस्टम प्रॉम्प्ट और टूल के बीच रखे RAG अंश हर क्वेरी पर अलग होते हैं और टूल वाली परत भी तोड़ देते हैं।

कोड में कैश के अनुकूल अनुरोध कैसे बनाएँ?

हर परत को सिर्फ़ स्थिर इनपुट का फ़ंक्शन बनाएँ, और तय तरीक़े से सीरियलाइज़ करें:

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

SYSTEM = open("prompts/system.md").read()  # versioned file, no templating

def stable_tools(registry: dict) -> list:
    # Sort by name, sort keys inside each schema.
    return [json.loads(json.dumps(registry[name], sort_keys=True)) for name in sorted(registry)]

def docs_block(paths: list[str]) -> str:
    parts = [f"=== {p} ===\n{open(p).read()}" for p in sorted(paths)]
    return "\n\n".join(parts)

def build_messages(history: list, user_text: str, now_iso: str, doc_paths: list[str]):
    return (
        [{"role": "system", "content": SYSTEM},
         {"role": "user", "content": docs_block(doc_paths)}]
        + history                                   # append-only
        + [{"role": "user", "content": f"(now: {now_iso})\n{user_text}"}]
    )

resp = client.chat.completions.create(
    model="broadnet/deepseek-v4.1-flash",
    messages=build_messages(history, question, now_iso, files),
    tools=stable_tools(TOOLS),
)
history += [{"role": "user", "content": question}, resp.choices[0].message.model_dump(exclude_none=True)]

दो बातें। मौजूदा समय आख़िरी संदेश में जाता है, सिस्टम प्रॉम्प्ट में नहीं। और इतिहास असिस्टेंट का संदेश ठीक वैसा ही सहेजता है जैसा लौटा था, ताकि अगली कॉल हूबहू वही बाइट दोबारा भेजे।

कैसे साबित करें कि प्रीफ़िक्स कैश हो रहा है?

CI या नोटबुक में दो कॉल वाला टेस्ट चलाएँ:

  1. अपने असली सिस्टम प्रॉम्प्ट, टूल और डॉक्यूमेंट के साथ एक अनुरोध बनाएँ।
  2. उसे भेजें। usage.prompt_tokens नोट करें।
  3. सिर्फ़ आख़िरी यूज़र संदेश बदलें और फिर भेजें।
  4. दूसरी कॉल पर usage.prompt_tokens_details.cached_tokens पढ़ें। इसे साझा प्रीफ़िक्स का लगभग पूरा हिस्सा कवर करना चाहिए।
  5. अगर यह शून्य या छोटा है, तो सीरियलाइज़ हुए अनुरोध बॉडी का बाइट-दर-बाइट डिफ़ निकालें। पहला अंतर ही आपका कैश तोड़ने वाला है।

ज़्यादातर प्रोवाइडरों पर कैशिंग बेस्ट-एफ़र्ट है, और DeepSeek का डॉक्यूमेंटेशन यह सीधे कहता है, इसलिए एक अकेला मिस बग का सबूत नहीं है। लगातार मिस है। अपने usage लॉग में हर अनुरोध पर कैश्ड और प्रॉम्प्ट टोकन का अनुपात ट्रैक करें, और प्रॉम्प्ट कैशिंग कैलकुलेटर से देखें कि ऊँचा हिट रेट कितना बचाता है।

एजेंट और लंबे कॉन्टेक्स्ट के लिए इसमें क्या बदलता है?

एजेंट को सबसे ज़्यादा फ़ायदा होता है, क्योंकि वे हर टास्क में वही बड़ा प्रीफ़िक्स दर्जनों बार दोबारा भेजते हैं। दो आदतें मायने रखती हैं:

  • हर टास्क की एक बातचीत। हर उप-स्टेप के लिए नई बातचीत शुरू करने से प्रीफ़िक्स फेंक दिया जाता है।
  • फ़ाइलें एक बार, ऊपर के पास पढ़ें। अगर एजेंट कोई फ़ाइल दोबारा पढ़ता है, तो पुरानी कॉपी बदलने के बजाय नई कॉपी जोड़ें, जब तक फ़ाइल बदली न हो।

1M टोकन की कॉन्टेक्स्ट विंडो में परत 3 पूरी रिपॉज़िटरी रख सकती है। प्रति-टोकन key पर यह तभी किफ़ायती है जब यह कैश हो, इसलिए प्रॉम्प्ट बड़े होने के साथ परतों का क्रम और अहम होता जाता है। कैश्ड प्रीफ़िक्स आम तौर पर पहले टोकन तक का समय भी घटाते हैं; देखें TTFT बनाम थ्रूपुट।

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

BroadNet Inference पर usage ब्लॉक prompt_tokens_details.cached_tokens रिपोर्ट करता है जब मॉडल इसे रिपोर्ट करता है, और DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B पर कैश्ड इनपुट प्राइसिंग पेज पर लिखी कम दर पर बिल होता है। BroadNet अपने डॉक्यूमेंटेशन में स्पष्ट कैश ब्रेकपॉइंट या कैश key पैरामीटर नहीं देता, इसलिए ऊपर का लेआउट ही पूरी तकनीक है। अनलिमिटेड प्लान पर कैश बिल नहीं बदलता, क्योंकि सेशन में कोई टोकन मीटर नहीं है, पर यही ढाँचा फिर भी लेटेंसी में मदद करता है।

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

मेरा प्रॉम्प्ट कैश हिट रेट कम क्यों है?

प्रॉम्प्ट की शुरुआत के पास कुछ हर कॉल पर बदल रहा है। आम वजहें हैं सिस्टम प्रॉम्प्ट में टाइमस्टैम्प या अनुरोध ID, अलग क्रम में सीरियलाइज़ हुए टूल, निर्देशों से पहले रखे गए रिट्रीव किए डॉक्यूमेंट, या ऐसा इतिहास जिसका सारांश बनाकर उसे दोबारा लिखा जाता है।

यूज़र का सवाल लंबे डॉक्यूमेंट से पहले रखें या बाद में?

बाद में। डॉक्यूमेंट पहले और सवाल आख़िर में रखें। तब डॉक्यूमेंट दोबारा इस्तेमाल होने लायक प्रीफ़िक्स बनाते हैं, और कई मॉडल सामग्री के बाद सवाल आने पर बेहतर जवाब भी देते हैं।

क्या टूल डेफ़िनिशन प्रॉम्प्ट कैशिंग तोड़ती हैं?

सिर्फ़ तब, जब वे बदलती हैं। टूल प्रीफ़िक्स का हिस्सा हैं, इसलिए वही सेट, उसी क्रम में, उसी JSON के साथ रखें। एक कॉल के लिए टूल सीमित करने हों, तो सूची बदलने के बजाय tool_choice इस्तेमाल करें।

क्या few-shot उदाहरणों का क्रम कैशिंग के लिए मायने रखता है?

हाँ। फेंटे गए उदाहरण हर बार अलग प्रीफ़िक्स बनाते हैं। क्रम तय रखें, या हर अनुरोध पर बदलने वाले उदाहरण स्थिर हिस्से के बाद रखें।

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