---
title: "कैशिंग के लिए प्रॉम्प्ट का ढाँचा: स्थिर प्रीफ़िक्स | BroadRouter"
description: "LLM प्रॉम्प्ट को ऐसे सजाएँ कि कैश्ड प्रीफ़िक्स एक जैसा रहे: सिस्टम प्रॉम्प्ट, टूल स्कीमा, डॉक्यूमेंट, सिर्फ़ आगे जुड़ता इतिहास, और इसे साबित करने वाला टेस्ट।"
url: https://broadrouter.com/hi/blog/prompt-structure-for-caching/
lang: hi
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/prompt-structure-for-caching/) (2026-11-16 को अपडेट किया गया).

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

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

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

## मुख्य बातें

-   कैश हूबहू प्रीफ़िक्स का मिलान करता है। एक बदला हुआ बाइट उसके बाद का सब कुछ अमान्य कर देता है, इसलिए परतों का क्रम उनके आकार से ज़्यादा अहम है।
-   चार परतें, सबसे स्थिर पहले: सिस्टम प्रॉम्प्ट, टूल, डॉक्यूमेंट, इतिहास। यूज़र का नया टर्न आख़िर में।
-   टूल और JSON डॉक्यूमेंट को क्रमबद्ध keys और तय सेपरेटर के साथ सीरियलाइज़ करें; डिक्शनरी का क्रम चुपचाप कैश तोड़ता है।
-   टूल डेफ़िनिशन हटाने के बजाय हर कॉल पर tool\_choice से टूल सीमित करें।
-   टेस्ट करें: वही प्रीफ़िक्स दो बार भेजें और जाँचें कि दूसरी कॉल पर prompt\_tokens\_details.cached\_tokens बढ़ता है।

**इस पेज पर**

1.  प्रॉम्प्ट का क्रम कैश हिट रेट क्यों तय करता है?
2.  परतों का सही क्रम क्या है?
3.  क्या चीज़ें बिना पता चले प्रीफ़िक्स तोड़ देती हैं?
4.  कोड में कैश के अनुकूल अनुरोध कैसे बनाएँ?
5.  कैसे साबित करें कि प्रीफ़िक्स कैश हो रहा है?
6.  एजेंट और लंबे कॉन्टेक्स्ट के लिए इसमें क्या बदलता है?
7.  BroadNet Inference कहाँ फ़िट होता है

[कैश्ड इनपुट टोकन](https://broadrouter.com/hi/glossary/cached-input-tokens/) सस्ते होते हैं, और BroadNet Inference पर DeepSeek V4.1 Flash उन्हें $0.175 की जगह $0.0055 प्रति 1M पर बिल करता है। [कैश्ड टोकन की व्याख्या](https://broadrouter.com/hi/blog/cached-input-tokens-explained/) कीमत और usage फ़ील्ड पढ़ने का तरीक़ा बताती है। यह पोस्ट डिज़ाइन के काम के बारे में है: प्रॉम्प्ट को कैसे सजाएँ कि कैश सच में हिट हो, और इसे कैसे साबित करें।

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

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

अंदर से सर्वर उस प्रीफ़िक्स के लिए बनाया गया [KV कैश](https://broadrouter.com/hi/glossary/kv-cache/) दोबारा इस्तेमाल करता है। इसलिए कैश पहले टोकन से एक सीधी रेखा है। पिछली कॉल से अलग पहला बाइट दोबारा इस्तेमाल होने वाले हिस्से को ख़त्म कर देता है। 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 अंश हर क्वेरी पर अलग होते हैं और टूल वाली परत भी तोड़ देते हैं।

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

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

```python
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 लॉग](https://broadrouter.com/hi/blog/llm-api-usage-logging/) में हर अनुरोध पर कैश्ड और प्रॉम्प्ट टोकन का अनुपात ट्रैक करें, और [प्रॉम्प्ट कैशिंग कैलकुलेटर](https://broadrouter.com/tools/prompt-caching-calculator/) से देखें कि ऊँचा हिट रेट कितना बचाता है।

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

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

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

[1M टोकन की कॉन्टेक्स्ट विंडो](https://broadrouter.com/hi/blog/million-token-context-window-guide/) में परत 3 पूरी रिपॉज़िटरी रख सकती है। प्रति-टोकन key पर यह तभी किफ़ायती है जब यह कैश हो, इसलिए प्रॉम्प्ट बड़े होने के साथ परतों का क्रम और अहम होता जाता है। कैश्ड प्रीफ़िक्स आम तौर पर पहले टोकन तक का समय भी घटाते हैं; देखें [TTFT बनाम थ्रूपुट](https://broadrouter.com/hi/blog/llm-latency-ttft-throughput/)।

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

BroadNet Inference पर usage ब्लॉक `prompt_tokens_details.cached_tokens` रिपोर्ट करता है जब मॉडल इसे रिपोर्ट करता है, और [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) और [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) पर कैश्ड इनपुट [प्राइसिंग पेज](https://broadrouter.com/hi/pricing/) पर लिखी कम दर पर बिल होता है। BroadNet अपने डॉक्यूमेंटेशन में स्पष्ट कैश ब्रेकपॉइंट या कैश key पैरामीटर नहीं देता, इसलिए ऊपर का लेआउट ही पूरी तकनीक है। अनलिमिटेड प्लान पर कैश बिल नहीं बदलता, क्योंकि सेशन में कोई टोकन मीटर नहीं है, पर यही ढाँचा फिर भी लेटेंसी में मदद करता है।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[सिस्टम प्रॉम्प्ट (system prompt)](https://broadrouter.com/hi/glossary/system-prompt/)

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

[कैश्ड इनपुट टोकन (cached input tokens)](https://broadrouter.com/hi/glossary/cached-input-tokens/)

कैश्ड इनपुट टोकन वे प्रॉम्प्ट टोकन हैं जिन्हें LLM प्रोवाइडर ने हाल ही में प्रोसेस किया है और दोबारा गणना करने के बजाय कैश से फिर इस्तेमाल कर सकता है, आम तौर पर सिस्टम प्रॉम्प्ट या डॉक्यूमेंट जैसा दोहराया गया प्रीफ़िक्स। प्रोवाइडर इनका बिल नए इनपुट टोकन से कम दर पर बनाते हैं।

[AI एजेंट (AI agent)](https://broadrouter.com/hi/glossary/agent/)

AI एजेंट ऐसा सिस्टम है जिसमें लैंग्वेज मॉडल किसी लक्ष्य की ओर अपने क़दम ख़ुद तय करता है: कौन-से टूल कॉल करने हैं, चुनता है, नतीजे पढ़ता है और अंतिम जवाब या किसी सीमा तक दोहराता रहता है। तय बिंदुओं पर मॉडल को कॉल करने वाली स्क्रिप्ट को आम तौर पर workflow कहते हैं।

[इनपुट और आउटपुट टोकन (input and output tokens)](https://broadrouter.com/hi/glossary/input-and-output-tokens/)

इनपुट टोकन वे टोकन हैं जिन्हें लैंग्वेज मॉडल किसी अनुरोध में पढ़ता है, जिनमें सिस्टम प्रॉम्प्ट, बातचीत का इतिहास, टूल डेफ़िनिशन और इमेज शामिल हैं। आउटपुट टोकन वे हैं जो वह जवाब में बनाता है, रीज़निंग समेत। LLM API आम तौर पर दोनों की कीमत अलग रखते हैं, और आउटपुट आम तौर पर महँगा होता है।

[पहले टोकन तक का समय (TTFT, time to first token)](https://broadrouter.com/hi/glossary/time-to-first-token/)

Time to first token (TTFT) वह समय है जो लैंग्वेज मॉडल को अनुरोध भेजने से पहला आउटपुट टोकन आने तक लगता है। इसमें नेटवर्क का समय, सर्वर पर कतार और prefill शामिल हैं, यानी वह चरण जिसमें मॉडल पूरा प्रॉम्प्ट पढ़ता है, इसलिए यह प्रॉम्प्ट की लंबाई और लोड के साथ बढ़ता है।

[कॉन्टेक्स्ट विंडो (context window)](https://broadrouter.com/hi/glossary/context-window/)

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

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

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

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

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

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

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

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

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

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

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

## आगे पढ़ें

-   [कैश्ड इनपुट टोकन क्या हैं: LLM API का बिल कैसे घटाएँ](https://broadrouter.com/hi/blog/cached-input-tokens-explained/)
-   [1M-टोकन कॉन्टेक्स्ट विंडो कब फ़ायदेमंद है (और कब नहीं)](https://broadrouter.com/hi/blog/million-token-context-window-guide/)
-   [फ़्लैट रेट बनाम प्रति टोकन LLM API: ब्रेक-ईवन का हिसाब](https://broadrouter.com/hi/blog/flat-rate-vs-pay-per-token-llm-api/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: chat completions स्ट्रीम करें और टूटे कनेक्शन सँभालें](https://broadrouter.com/hi/guides/streaming-chat-completions/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-prompt-structure-for-caching&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस, usage में कैश्ड टोकन (2026-11-16 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-prompt-structure-for-caching&utm_content=sources)
-   [OpenAI प्रॉम्प्ट कैशिंग गाइड, प्रीफ़िक्स मिलान और ढाँचे की सलाह (2026-11-14 को देखा गया)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [Anthropic प्रॉम्प्ट कैशिंग डॉक्यूमेंटेशन, कैश का क्रम: टूल, फिर सिस्टम, फिर संदेश (2026-11-16 को जाँचा गया)](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)
-   [DeepSeek API डॉक्यूमेंटेशन, कॉन्टेक्स्ट कैशिंग (2026-11-14 को देखा गया)](https://api-docs.deepseek.com/guides/kv_cache)
