हर एक जैसा LLM अनुरोध जो आप दो बार भेजते हैं, उसका भुगतान भी दो बार होता है। रिस्पॉन्स कैश पहली बार जवाब सहेजता है और अगली बार वही लौटा देता है, बिना किसी टोकन के बिल और बिना इंतज़ार के। विचार सीधा है। मुश्किल हिस्से हैं यह तय करना कि दो अनुरोध “एक जैसे” कब हैं, किन अनुरोधों को कभी स्टोरेज से जवाब नहीं देना चाहिए, और क्या आपका ट्रैफ़िक इतना दोहराता है कि इससे फ़र्क़ पड़े।
यह पोस्ट Python में SQLite पर एक छोटा एक्ज़ैक्ट-मैच कैश बनाती है, एक मॉक OpenAI-कम्पैटिबल सर्वर पर टेस्ट किया हुआ, और दिखाती है कि इसमें से कुछ भी लिखने से पहले अपने लॉग से हिट रेट कैसे मापें।
क्या रिस्पॉन्स कैशिंग और प्रॉम्प्ट कैशिंग एक ही चीज़ है?
नहीं। ये अलग चीज़ें बचाते हैं, और आप दोनों इस्तेमाल कर सकते हैं।
| प्रॉम्प्ट कैशिंग (प्रोवाइडर) | रिस्पॉन्स कैशिंग (आप) | |
|---|---|---|
| क्या दोबारा इस्तेमाल होता है | प्रॉम्प्ट की दोहराई गई शुरुआत | पूरा जवाब |
| कौन चलाता है | API प्रोवाइडर | आपका कोड |
| मॉडल फिर भी चलता है? | हाँ, नया जवाब लिखता है | नहीं |
| क्या बचाता है | इनपुट लागत का एक हिस्सा | इनपुट, आउटपुट और रीज़निंग टोकन, साथ में लेटेंसी |
| कब हिट होता है | साझा प्रीफ़िक्स, अलग सवाल | हूबहू वही अनुरोध |
कैश्ड इनपुट टोकन प्रोवाइडर वाला हिस्सा समझाता है, और कैशिंग के लिए प्रॉम्प्ट का ढाँचा दिखाता है कि प्रॉम्प्ट कैसे सजाएँ ताकि प्रीफ़िक्स दोबारा इस्तेमाल हो। प्रॉम्प्ट कैशिंग कैलकुलेटर इसकी कीमत निकालता है। रिस्पॉन्स कैश इन सबके आगे बैठता है: हिट होने पर कोई अनुरोध आपके सर्वर से बाहर नहीं जाता।
क्या कैश से सच में पैसे बचेंगे?
बनाने से पहले मापें। कई कैशिंग ट्यूटोरियल में लागत बचत के प्रतिशत किसी और के ट्रैफ़िक से आते हैं। आपकी संख्या एक ही बात पर निर्भर है: एक ही अनुरोध आपकी एक्सपायरी विंडो के अंदर कितनी बार दोबारा आता है।
अगर आप पहले से हर कॉल लॉग करते हैं, जैसे LLM API usage लॉगिंग में, तो एक फ़ील्ड जोड़ें: request_hash, यानी नीचे बताई गई कैश key। इसमें कोई प्रॉम्प्ट टेक्स्ट नहीं होता, इसलिए यह ऐसे लॉग में फ़िट होता है जो कंटेंट बाहर रखता है। फिर दोहराव गिनें:
import json
from collections import Counter
def potential_hit_rate(log_path: str) -> float:
"""Share of calls whose request_hash was already seen: an upper bound for an exact cache."""
hashes = [json.loads(line)["request_hash"] for line in open(log_path)]
seen, repeats = set(), 0
for h in hashes:
repeats += h in seen
seen.add(h)
print("top repeated requests:", Counter(hashes).most_common(3))
return repeats / len(hashes) if hashes else 0.0
print(f"potential hit rate: {potential_hit_rate('calls.jsonl'):.1%}")
20 कॉल के एक सिंथेटिक लॉग पर, जिसमें एक अनुरोध पाँच बार, दूसरा तीन बार और बारह अनोखे थे, इसने 30.0% का संभावित हिट रेट छापा। यह ऊपरी सीमा है: यह एक्सपायरी को नज़रअंदाज़ करता है, और मानता है कि हर दोहराव को स्टोरेज से देना सुरक्षित है।
फिर दर को पैसे में बदलें:
monthly saving = hit rate × requests per month
× (input tokens × input price + output tokens × output price) ÷ 1,000,000
आउटपुट टोकन में रीज़निंग शामिल है। BroadNet का डॉक्यूमेंटेशन कहता है कि DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब से पहले रीज़निंग करते हैं और रीज़निंग max_tokens में गिनी जाती है, इसलिए हिट उन टोकन को भी बचाता है जो आपको जवाब में कभी नहीं दिखते। completion_tokens लॉग किए गए usage से लें, जवाब की लंबाई से नहीं।
टोकन में एक उदाहरण: 100,000 अनुरोध प्रति माह, हर एक में 1,200 इनपुट और 150 आउटपुट टोकन, 30% हिट रेट के साथ, 3.6 करोड़ (36M) इनपुट टोकन और 45 लाख (4.5M) आउटपुट टोकन बचाते हैं। DeepSeek V4.1 Flash पर ये क्रमशः $0.175 और $0.52 प्रति 1M पर बिल होते हैं; अपनी संख्याएँ LLM API लागत कैलकुलेटर में डालें। अगर उस इनपुट का ज़्यादातर हिस्सा पहले ही प्रोवाइडर कैश हिट था, तो इनपुट की बचत कम कैश्ड दर पर होती है (इसी मॉडल पर $0.0055 प्रति 1M), इसलिए अक्सर आउटपुट वाला हिस्सा ज़्यादा मायने रखता है।
कैश key में क्या जाता है?
वह सब जो जवाब बदल सकता है, और कुछ नहीं।
- शामिल करें:
model, पूरीmessagesसूची (सिस्टम प्रॉम्प्ट समेत),temperature,top_p,max_tokens,seed,response_format,tools,tool_choiceऔरreasoning_effort। - एक प्रॉम्प्ट वर्ज़न जोड़ें जो आपके नियंत्रण में हो, जैसे
faq-v3। जब आप प्रॉम्प्ट टेम्पलेट, रिट्रीवल डेटा या पोस्ट-प्रोसेसिंग बदलें, जो अनुरोध बॉडी में नहीं दिखती, तो इसे बढ़ाएँ। - बाहर रखें वह सब जो हर कॉल पर बदलता है पर जवाब नहीं बदलता: अनुरोध ID, टाइमस्टैम्प, ट्रेस हेडर,
userफ़ील्ड जो आप सिर्फ़ दुरुपयोग ट्रैकिंग के लिए भेजते हैं।
key की सामग्री हर बार एक ही तरह सीरियलाइज़ करें। Python का json.dumps, sort_keys=True और separators=(",", ":") के साथ, डिक्शनरी के क्रम से अलग एक मानक स्ट्रिंग देता है; ensure_ascii=False अरबी और दूसरे ग़ैर-लैटिन टेक्स्ट को एस्केप के बजाय UTF-8 में रखता है। इसे SHA-256 से हैश करें।
छूटा हुआ फ़ील्ड ख़तरनाक ग़लती है। अगर max_tokens key में नहीं है, तो छोटी सीमा पर कटा जवाब उस अनुरोध को दे दिया जाएगा जिसने लंबे जवाब की अनुमति दी थी।
कैश: SQLite, TTL और स्किप नीति
import hashlib, json, sqlite3, time
# Every field that changes the answer belongs in the key.
KEY_FIELDS = ("model", "messages", "temperature", "top_p", "max_tokens", "seed",
"response_format", "tools", "tool_choice", "reasoning_effort")
def cache_key(params: dict, prompt_version: str) -> str:
material = {k: params[k] for k in KEY_FIELDS if k in params}
material["prompt_version"] = prompt_version
canon = json.dumps(material, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
return hashlib.sha256(canon.encode("utf-8")).hexdigest()
class ResponseCache:
def __init__(self, path="llm_cache.sqlite", ttl_s=7 * 86400):
self.db, self.ttl = sqlite3.connect(path), ttl_s
self.db.execute("CREATE TABLE IF NOT EXISTS cache (k TEXT PRIMARY KEY, created REAL,"
" body TEXT, prompt_tokens INT, completion_tokens INT)")
self.hits = self.misses = self.skips = self.saved_in = self.saved_out = 0
def create(self, client, prompt_version: str, **params):
if params.get("stream") or params.get("temperature", 1) > 0:
self.skips += 1 # not cacheable: call the model directly
return client.chat.completions.create(**params)
k = cache_key(params, prompt_version)
row = self.db.execute("SELECT body, created, prompt_tokens, completion_tokens"
" FROM cache WHERE k = ?", (k,)).fetchone()
if row and time.time() - row[1] < self.ttl:
self.hits += 1; self.saved_in += row[2]; self.saved_out += row[3]
return json.loads(row[0]) # a plain dict, not an SDK object
self.misses += 1
r = client.chat.completions.create(**params)
choice = r.choices[0]
if choice.finish_reason == "stop" and not choice.message.tool_calls:
self.db.execute("INSERT OR REPLACE INTO cache VALUES (?, ?, ?, ?, ?)",
(k, time.time(), r.model_dump_json(),
r.usage.prompt_tokens, r.usage.completion_tokens))
self.db.commit()
return r.model_dump()
और इस पर एक रन:
import os
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
cache = ResponseCache("demo.sqlite", ttl_s=86400)
SYSTEM = {"role": "system", "content": "Answer questions about our refund policy in one sentence."}
questions = ["How long do refunds take?", "Can I refund a gift card?",
"How long do refunds take?", "How long do refunds take?", "Can I refund a gift card?"]
for q in questions:
r = cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0,
max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": q}])
print(r["choices"][0]["message"]["content"])
# a personalised, sampled request is never cached
cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0.7,
messages=[SYSTEM, {"role": "user", "content": "Write me a friendly reminder"}])
# a new prompt version is a new key
cache.create(client, "faq-v4", model="broadnet/deepseek-v4.1-flash", temperature=0,
max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": "How long do refunds take?"}])
print(f"hits={cache.hits} misses={cache.misses} skipped={cache.skips} "
f"saved_input={cache.saved_in} saved_output={cache.saved_out}")
हमने इसे OpenAI Python SDK 3.51.0 के साथ एक लोकल मॉक सर्वर पर चलाया, जो अपस्ट्रीम कॉल गिनता था और हर जवाब पर 1,200 प्रॉम्प्ट और 150 completion टोकन रिपोर्ट करता था (कोई लाइव API कॉल नहीं)। सात अनुरोधों ने चार अपस्ट्रीम कॉल कीं। स्क्रिप्ट ने hits=3 misses=3 skipped=1 saved_input=3600 saved_output=450 छापा। उसी डेटाबेस फ़ाइल पर दोबारा चलाने पर, कैश हो सकने वाले सभी छह अनुरोध हिट हुए (hits=6 misses=0): SQLite रीस्टार्ट के बाद भी कैश रखता है। अलग क्रम में उन्हीं फ़ील्ड से बनी key मैच हुईं।
कोड पर टिप्पणियाँ:
max_tokens=1200जवाब से पहले रीज़निंग के लिए जगह छोड़ता है। छोटी सीमा पर रीज़निंग मॉडल ख़ाली जवाब लौटा सकता है (क्यों)। ऐसे जवाब सहेजे नहीं जाते, क्योंकिfinish_reason,stopनहीं बल्किlengthहोता है।- हिट एक dict लौटाते हैं। मिस भी
model_dump()लौटाते हैं, ताकि कॉल करने वालों को एक ही आकार मिले। अगर आपका कोड SDK ऑब्जेक्ट की उम्मीद करता है, तो दोनों को रैप करें। temperatureन दिया गया हो, तो उसे सैंपल किया हुआ माना जाता है। तब सर्वर अपना डिफ़ॉल्ट लगाता है, जो 0 से ऊपर हो सकता है, इसलिए रैपर तब तक कैश नहीं करता जब तक आप साफ़ तौर पर 0 सेट न करें।- SQLite एक या कुछ प्रोसेस के लिए ठीक है। कई सर्वर के लिए वही key और TTL लॉजिक Redis या अपने डेटाबेस में रखें।
कैश से कभी क्या नहीं देना चाहिए?
- सैंपल किए जवाब (temperature 0 से ऊपर)। आपने विविधता चुनी थी। कैशिंग उसे हटा देती है, और “regenerate” दबाने वाले यूज़र को वही टेक्स्ट मिलता है।
- निजी जवाब, जब तक यूज़र ID key में न हो। “summarise my account” भेजने वाले दो यूज़र के अकाउंट अलग हैं। बेहतर: सिर्फ़ वे अनुरोध कैश करें जिनके संदेशों में हर यूज़र का अलग डेटा न हो।
- टूल कॉल। टूल कॉल कुछ करने का निर्देश है। स्टोरेज से “refund order 1182” दोबारा चलाने से साइड इफ़ेक्ट दोहराया जा सकता है, और सही अगला क़दम मौजूदा हालत पर निर्भर करता है। रैपर
tool_callsवाला कोई भी जवाब सहेजने से मना करता है। - स्ट्रीम किए जवाब। रैपर
stream=Trueपर कैश को बायपास करता है। स्ट्रीम कैश करने का मतलब है उसे बफ़र करना, जाँचना कि वह पूरी हुई, और दोबारा चलाना, जो चैट UI के लिए शायद ही कभी फ़ायदेमंद है। - कटे या फ़ेल हुए जवाब। सिर्फ़
finish_reason == "stop"सहेजें। एक हफ़्ते के लिए कैश हुआ कटा जवाब या एरर ऐसा बग है जो मॉडल की समस्या जैसा दिखता है। - समय पर निर्भर जवाब। “आज की एक्सचेंज रेट क्या है?” को छोटा TTL चाहिए या कोई कैश नहीं।
जो अच्छी तरह कैश होता है: इनपुट के तय सेट का क्लासिफ़िकेशन, उन डॉक्यूमेंट से एक्सट्रैक्शन जिन्हें आप दोबारा प्रोसेस करते हैं, तय प्रॉम्प्ट से FAQ जवाब, टेस्ट सूट और eval जो आप दोबारा चलाते हैं, और डेवलपमेंट लूप जहाँ आप एक ही अनुरोध बार-बार भेजते हैं।
कैश्ड जवाब कब एक्सपायर होने चाहिए?
तीन तरह से अमान्य करें:
- TTL। हर एंट्री की समय-सीमा: स्थिर FAQ जवाबों के लिए दिन, लाइव डेटा पढ़ने वाली किसी भी चीज़ के लिए मिनट।
- key में वर्ज़न। जब सिस्टम प्रॉम्प्ट, रिट्रीवल इंडेक्स या आउटपुट स्कीमा बदले, तो प्रॉम्प्ट वर्ज़न बदलें। पुरानी एंट्री मैच होना बंद कर देती हैं और समय के साथ हट जाती हैं।
- key में मॉडल। यह पहले से वहाँ है, इसलिए एक मॉडल से दूसरे पर जाने पर नया कैश शुरू होता है, जो स्विच का मूल्यांकन करते समय आप चाहते भी हैं।
एक्सपायर हुई पंक्तियाँ तय समय पर हटाएँ (DELETE FROM cache WHERE created < ?)। वरना फ़ाइल बस बढ़ती जाती है।
एक अतिरिक्त फ़ायदा भी है। सर्विंग इंजन एक जैसे इनपुट पर एक जैसे आउटपुट का वादा नहीं करते: vLLM का डॉक्यूमेंटेशन कहता है कि यह “does not guarantee the reproducibility of the results by default” (अनुवाद: डिफ़ॉल्ट रूप से नतीजों के दोहराए जा सकने की गारंटी नहीं देता)। कैश एंट्री के रहने तक हर यूज़र को एक ही सवाल का एक ही जवाब देता है।
सिमेंटिक कैशिंग का क्या?
सिमेंटिक कैश हर सवाल को एम्बेड करता है और जब नया सवाल काफ़ी क़रीब हो, तो सहेजा गया जवाब लौटाता है, ताकि “how long is a refund?” भी “how long do refunds take?” से हिट हो सके। GPTCache सबसे जाना-माना ओपन-सोर्स उदाहरण है। उसका README कहता है कि वह सिमिलैरिटी सर्च के लिए वेक्टर स्टोर और हिट तय करने के लिए एक सिमिलैरिटी इवैल्युएटर इस्तेमाल करता है, चेतावनी देता है कि “you may encounter false positives during cache hits and false negatives during cache misses” (अनुवाद: कैश हिट में फ़ॉल्स पॉज़िटिव और कैश मिस में फ़ॉल्स नेगेटिव मिल सकते हैं), और बताता है कि एम्बेडिंग बंद करने पर यह कीवर्ड-मैचिंग कैश बन जाता है।
दो व्यावहारिक बातें। पहली, इसके लिए एक एम्बेडिंग मॉडल और वेक्टर स्टोर चाहिए। BroadNet Inference एम्बेडिंग नहीं देता, इसलिए उस परत के लिए आपको दूसरा प्रोवाइडर या लोकल मॉडल इस्तेमाल करना होगा; एम्बेडिंग लागत कैलकुलेटर विकल्पों की कीमत निकालता है। दूसरी, फ़ॉल्स हिट किसी दूसरे सवाल का पूरे भरोसे वाला जवाब लौटाता है। सख़्त सिमिलैरिटी सीमा रखें, उसे असली लगभग-मिलते जोड़ों पर टेस्ट करें, और सिमेंटिक कैशिंग कम जोखिम वाले जवाबों के लिए रखें। दोनों हालात में एक्ज़ैक्ट कैश आगे रखें: उसे जाँचने में कोई ख़र्च नहीं, और वह पूछे गए सवाल के बारे में कभी ग़लत नहीं होता।
प्राइवेसी के लिए कैश का क्या मतलब है?
कैश प्रॉम्प्ट और जवाबों का भंडार है। इससे बदलता है कि आपका डेटा कहाँ रहता है।
BroadNet का इन्फ़रेंस प्राइवेसी स्टेटमेंट, 2026-11-15 को जाँचा गया, कहता है कि उसका गेटवे कोई प्रॉम्प्ट, संदेश, रिस्पॉन्स या ट्रांसक्रिप्ट नहीं रखता, जबकि बिना कंटेंट वाले ट्रैफ़िक और usage रिकॉर्ड (टोकन गिनती, लागत, समय) रखे जाते हैं। इन्फ़रेंस कंटेंट नहीं रखा जाता। ज़रूरी अकाउंट, बिलिंग और सुरक्षा मेटाडेटा उस स्टेटमेंट में बताए अनुसार रखा जाता है। रिस्पॉन्स कैश जोड़ते ही आपका सिस्टम वह कंटेंट रखता है जो प्रोवाइडर नहीं रखता। इसे यूज़र डेटा के किसी भी दूसरे भंडार की तरह बरतें:
- जहाँ हो सके, सिर्फ़ बिना निजी डेटा वाले अनुरोध कैश करें, जिससे हिट रेट भी बढ़ता है।
- TTL इतना छोटा रखें कि आपकी रिटेंशन नीति में फ़िट हो, और तय समय पर हटाएँ।
- फ़ाइल या टेबल को स्टोरेज में एन्क्रिप्ट करें और सीमित करें कि कौन उसे पढ़ सकता है।
- अगर कैश में यूज़र का टेक्स्ट हो सकता है, तो डेटा हटाने के अनुरोधों में उसे भी शामिल करें।
LLM API को संवेदनशील डेटा भेजना उस चेकलिस्ट का बाक़ी हिस्सा कवर करता है।
कैशिंग दूसरे लागत नियंत्रणों के साथ कैसे फ़िट होती है?
कैशिंग दोहराई गई कॉल हटाती है। अनोखी कॉल के लिए यह कुछ नहीं करती, इसलिए यह दूसरे नियंत्रणों की जगह नहीं, उनके साथ रहती है: छोटे प्रॉम्प्ट, प्रोवाइडर की प्रॉम्प्ट कैशिंग, हर अनुरोध पर max_tokens की सीमा, और LLM API ख़र्च नियंत्रण वाले बजट और लूप सीमाएँ। बड़े एक बार के जॉब के लिए, भेजने से पहले इनपुट से डुप्लिकेट हटाएँ; यह कैश वाला ही विचार है, एक बार किया हुआ। Batch API के बिना बड़ा जॉब प्रोसेस करना जॉब वाला पहलू दिखाता है।
फ़्लैट-रेट प्लान पर हिसाब बदल जाता है। BroadNet के DeepSeek सेशन में कोई टोकन मीटर नहीं है, इसलिए वहाँ कैश हिट से पैसा नहीं बचता। फिर भी समय बचता है: सेशन एक समय में एक अनुरोध चलाता है, इसलिए हर छोड़ा गया दोहराव सेशन को नए काम के लिए खाली करता है।
BroadNet Inference कहाँ फ़िट होता है
BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference, DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B और Gemma 4 VL 26B को एक OpenAI-कम्पैटिबल /v1/chat/completions एंडपॉइंट के पीछे देता है, इसलिए ऊपर का रैपर सिर्फ़ base URL बदलकर OpenAI Python SDK के साथ काम करता है। इसमें अपनी कोई रिस्पॉन्स-कैशिंग सुविधा नहीं है; इस पोस्ट का कैश आपका है। प्रोवाइडर की तरफ़ के कैश हिट usage.prompt_tokens_details.cached_tokens में रिपोर्ट होते हैं और कैश्ड इनपुट कीमत पर बिल होते हैं, उसके API रेफ़रंस के अनुसार। हर मॉडल की कीमतें प्राइसिंग पेज पर हैं।
