---
title: "LLM API रिस्पॉन्स कैश करें: Python, SQLite | BroadRouter"
description: "Python में LLM API रिस्पॉन्स के लिए टेस्ट किया हुआ एक्ज़ैक्ट-मैच कैश: key में क्या जाता है, क्या कभी कैश न करें, TTL, प्राइवेसी और बनाने से पहले हिट रेट कैसे मापें।"
url: https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

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

# LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश

BroadNet Inference टीम · 8 मिनट में पढ़ें · प्रकाशित 2026-11-15

पूरे अनुरोध (मॉडल, संदेश, temperature, max\_tokens, response\_format, टूल, रीज़निंग सेटिंग और आपका प्रॉम्प्ट वर्ज़न) को हैश करके एक key बनाएँ, और जवाब उसके नीचे एक्सपायरी के साथ सहेजें। सहेजा गया जवाब सिर्फ़ डिटरमिनिस्टिक, बिना साइड इफ़ेक्ट वाले अनुरोधों को दें। पहले अपने लॉग में मापें कि एक जैसे अनुरोध कितनी बार दोहराए जाते हैं: वही हिस्सा एक्ज़ैक्ट कैश की अधिकतम बचत है।

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

-   एक्ज़ैक्ट कैश पूरी कॉल बचाता है, आउटपुट और रीज़निंग टोकन समेत, पर सिर्फ़ बाइट-दर-बाइट एक जैसे अनुरोधों के लिए। दूसरे शब्दों में पूछे गए सवाल हमेशा मिस होते हैं।
-   जवाब बदलने वाला हर पैरामीटर key में डालें, साथ में प्रॉम्प्ट वर्ज़न। एक भी छूटा तो ग़लत जवाब मिलते हैं; टाइमस्टैम्प जैसा शोर जोड़ा तो हर अनुरोध मिस होता है।
-   सैंपल किए जवाब (temperature 0 से ऊपर), स्ट्रीम किए जवाब, टूल कॉल, या max\_tokens पर कटे जवाब कैश न करें।
-   पहले मापें: अपने usage लॉग में हर अनुरोध का हैश बनाएँ और दोहराव गिनें। प्रकाशित बचत के आँकड़े आपके ट्रैफ़िक के बारे में कुछ नहीं बताते।
-   कैश प्रॉम्प्ट और जवाब सहेजता है। अगर आपका प्रोवाइडर कोई इन्फ़रेंस कंटेंट नहीं रखता, तो अब वह कंटेंट कैश में रहता है, इसलिए उसे TTL और एक्सेस नियम दें।

**इस पेज पर**

1.  क्या रिस्पॉन्स कैशिंग और प्रॉम्प्ट कैशिंग एक ही चीज़ है?
2.  क्या कैश से सच में पैसे बचेंगे?
3.  कैश key में क्या जाता है?
4.  कैश: SQLite, TTL और स्किप नीति
5.  कैश से कभी क्या नहीं देना चाहिए?
6.  कैश्ड जवाब कब एक्सपायर होने चाहिए?
7.  सिमेंटिक कैशिंग का क्या?
8.  प्राइवेसी के लिए कैश का क्या मतलब है?
9.  कैशिंग दूसरे लागत नियंत्रणों के साथ कैसे फ़िट होती है?
10.  BroadNet Inference कहाँ फ़िट होता है

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

यह पोस्ट Python में SQLite पर एक छोटा एक्ज़ैक्ट-मैच कैश बनाती है, एक मॉक OpenAI-कम्पैटिबल सर्वर पर टेस्ट किया हुआ, और दिखाती है कि इसमें से कुछ भी लिखने से पहले अपने लॉग से हिट रेट कैसे मापें।

## क्या रिस्पॉन्स कैशिंग और प्रॉम्प्ट कैशिंग एक ही चीज़ है?

नहीं। ये अलग चीज़ें बचाते हैं, और आप दोनों इस्तेमाल कर सकते हैं।

|  | प्रॉम्प्ट कैशिंग (प्रोवाइडर) | रिस्पॉन्स कैशिंग (आप) |
| --- | --- | --- |
| क्या दोबारा इस्तेमाल होता है | प्रॉम्प्ट की दोहराई गई शुरुआत | पूरा जवाब |
| कौन चलाता है | API प्रोवाइडर | आपका कोड |
| मॉडल फिर भी चलता है? | हाँ, नया जवाब लिखता है | नहीं |
| क्या बचाता है | इनपुट लागत का एक हिस्सा | इनपुट, आउटपुट और रीज़निंग टोकन, साथ में लेटेंसी |
| कब हिट होता है | साझा प्रीफ़िक्स, अलग सवाल | हूबहू वही अनुरोध |

[कैश्ड इनपुट टोकन](https://broadrouter.com/hi/blog/cached-input-tokens-explained/) प्रोवाइडर वाला हिस्सा समझाता है, और [कैशिंग के लिए प्रॉम्प्ट का ढाँचा](https://broadrouter.com/hi/blog/prompt-structure-for-caching/) दिखाता है कि प्रॉम्प्ट कैसे सजाएँ ताकि प्रीफ़िक्स दोबारा इस्तेमाल हो। [प्रॉम्प्ट कैशिंग कैलकुलेटर](https://broadrouter.com/tools/prompt-caching-calculator/) इसकी कीमत निकालता है। रिस्पॉन्स कैश इन सबके आगे बैठता है: हिट होने पर कोई अनुरोध आपके सर्वर से बाहर नहीं जाता।

## क्या कैश से सच में पैसे बचेंगे?

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

अगर आप पहले से हर कॉल लॉग करते हैं, जैसे [LLM API usage लॉगिंग](https://broadrouter.com/hi/blog/llm-api-usage-logging/) में, तो एक फ़ील्ड जोड़ें: `request_hash`, यानी नीचे बताई गई कैश key। इसमें कोई प्रॉम्प्ट टेक्स्ट नहीं होता, इसलिए यह ऐसे लॉग में फ़िट होता है जो कंटेंट बाहर रखता है। फिर दोहराव गिनें:

```python
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% का संभावित हिट रेट छापा। यह ऊपरी सीमा है: यह एक्सपायरी को नज़रअंदाज़ करता है, और मानता है कि हर दोहराव को स्टोरेज से देना सुरक्षित है।

फिर दर को पैसे में बदलें:

```text
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](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) पर ये क्रमशः $0.175 और $0.52 प्रति 1M पर बिल होते हैं; अपनी संख्याएँ [LLM API लागत कैलकुलेटर](https://broadrouter.com/tools/llm-api-cost-calculator/) में डालें। अगर उस इनपुट का ज़्यादातर हिस्सा पहले ही प्रोवाइडर कैश हिट था, तो इनपुट की बचत कम कैश्ड दर पर होती है (इसी मॉडल पर $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 और स्किप नीति

```python
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()
```

और इस पर एक रन:

```python
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`** जवाब से पहले रीज़निंग के लिए जगह छोड़ता है। छोटी सीमा पर रीज़निंग मॉडल ख़ाली जवाब लौटा सकता है ([क्यों](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/))। ऐसे जवाब सहेजे नहीं जाते, क्योंकि `finish_reason`, `stop` नहीं बल्कि `length` होता है।
-   **हिट एक dict लौटाते हैं।** मिस भी `model_dump()` लौटाते हैं, ताकि कॉल करने वालों को एक ही आकार मिले। अगर आपका कोड SDK ऑब्जेक्ट की उम्मीद करता है, तो दोनों को रैप करें।
-   **`temperature` न दिया गया हो, तो उसे सैंपल किया हुआ माना जाता है।** तब सर्वर अपना डिफ़ॉल्ट लगाता है, जो 0 से ऊपर हो सकता है, इसलिए रैपर तब तक कैश नहीं करता जब तक आप साफ़ तौर पर 0 सेट न करें।
-   **SQLite एक या कुछ प्रोसेस के लिए ठीक है।** कई सर्वर के लिए वही key और TTL लॉजिक Redis या अपने डेटाबेस में रखें।

## कैश से कभी क्या नहीं देना चाहिए?

-   **सैंपल किए जवाब (temperature 0 से ऊपर)।** आपने विविधता चुनी थी। कैशिंग उसे हटा देती है, और “regenerate” दबाने वाले यूज़र को वही टेक्स्ट मिलता है।
-   **निजी जवाब**, जब तक यूज़र ID key में न हो। “summarise my account” भेजने वाले दो यूज़र के अकाउंट अलग हैं। बेहतर: सिर्फ़ वे अनुरोध कैश करें जिनके संदेशों में हर यूज़र का अलग डेटा न हो।
-   **टूल कॉल।** [टूल कॉल](https://broadrouter.com/hi/glossary/tool-calling/) कुछ करने का निर्देश है। स्टोरेज से “refund order 1182” दोबारा चलाने से साइड इफ़ेक्ट दोहराया जा सकता है, और सही अगला क़दम मौजूदा हालत पर निर्भर करता है। रैपर `tool_calls` वाला कोई भी जवाब सहेजने से मना करता है।
-   **स्ट्रीम किए जवाब।** रैपर `stream=True` पर कैश को बायपास करता है। स्ट्रीम कैश करने का मतलब है उसे बफ़र करना, जाँचना कि वह पूरी हुई, और दोबारा चलाना, जो चैट UI के लिए शायद ही कभी फ़ायदेमंद है।
-   **कटे या फ़ेल हुए जवाब।** सिर्फ़ `finish_reason == "stop"` सहेजें। एक हफ़्ते के लिए कैश हुआ कटा जवाब या एरर ऐसा बग है जो मॉडल की समस्या जैसा दिखता है।
-   **समय पर निर्भर जवाब।** “आज की एक्सचेंज रेट क्या है?” को छोटा TTL चाहिए या कोई कैश नहीं।

जो अच्छी तरह कैश होता है: इनपुट के तय सेट का क्लासिफ़िकेशन, उन डॉक्यूमेंट से एक्सट्रैक्शन जिन्हें आप दोबारा प्रोसेस करते हैं, तय प्रॉम्प्ट से FAQ जवाब, टेस्ट सूट और eval जो आप दोबारा चलाते हैं, और डेवलपमेंट लूप जहाँ आप एक ही अनुरोध बार-बार भेजते हैं।

## कैश्ड जवाब कब एक्सपायर होने चाहिए?

तीन तरह से अमान्य करें:

1.  **TTL।** हर एंट्री की समय-सीमा: स्थिर FAQ जवाबों के लिए दिन, लाइव डेटा पढ़ने वाली किसी भी चीज़ के लिए मिनट।
2.  **key में वर्ज़न।** जब सिस्टम प्रॉम्प्ट, रिट्रीवल इंडेक्स या आउटपुट स्कीमा बदले, तो प्रॉम्प्ट वर्ज़न बदलें। पुरानी एंट्री मैच होना बंद कर देती हैं और समय के साथ हट जाती हैं।
3.  **key में मॉडल।** यह पहले से वहाँ है, इसलिए एक मॉडल से दूसरे पर जाने पर नया कैश शुरू होता है, जो [स्विच का मूल्यांकन](https://broadrouter.com/hi/blog/evaluate-llm-before-switching/) करते समय आप चाहते भी हैं।

एक्सपायर हुई पंक्तियाँ तय समय पर हटाएँ (`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” (अनुवाद: कैश हिट में फ़ॉल्स पॉज़िटिव और कैश मिस में फ़ॉल्स नेगेटिव मिल सकते हैं), और बताता है कि एम्बेडिंग बंद करने पर यह कीवर्ड-मैचिंग कैश बन जाता है।

दो व्यावहारिक बातें। पहली, इसके लिए एक [एम्बेडिंग](https://broadrouter.com/hi/glossary/embeddings/) मॉडल और वेक्टर स्टोर चाहिए। BroadNet Inference एम्बेडिंग नहीं देता, इसलिए उस परत के लिए आपको दूसरा प्रोवाइडर या लोकल मॉडल इस्तेमाल करना होगा; [एम्बेडिंग लागत कैलकुलेटर](https://broadrouter.com/tools/embedding-cost-calculator/) विकल्पों की कीमत निकालता है। दूसरी, फ़ॉल्स हिट किसी दूसरे सवाल का पूरे भरोसे वाला जवाब लौटाता है। सख़्त सिमिलैरिटी सीमा रखें, उसे असली लगभग-मिलते जोड़ों पर टेस्ट करें, और सिमेंटिक कैशिंग कम जोखिम वाले जवाबों के लिए रखें। दोनों हालात में एक्ज़ैक्ट कैश आगे रखें: उसे जाँचने में कोई ख़र्च नहीं, और वह पूछे गए सवाल के बारे में कभी ग़लत नहीं होता।

## प्राइवेसी के लिए कैश का क्या मतलब है?

कैश प्रॉम्प्ट और जवाबों का भंडार है। इससे बदलता है कि आपका डेटा कहाँ रहता है।

BroadNet का [इन्फ़रेंस प्राइवेसी स्टेटमेंट](https://www.broadnet.ai/inference-privacy), 2026-11-15 को जाँचा गया, कहता है कि उसका गेटवे कोई प्रॉम्प्ट, संदेश, रिस्पॉन्स या ट्रांसक्रिप्ट नहीं रखता, जबकि बिना कंटेंट वाले ट्रैफ़िक और usage रिकॉर्ड (टोकन गिनती, लागत, समय) रखे जाते हैं। इन्फ़रेंस कंटेंट नहीं रखा जाता। ज़रूरी अकाउंट, बिलिंग और सुरक्षा मेटाडेटा उस स्टेटमेंट में बताए अनुसार रखा जाता है। रिस्पॉन्स कैश जोड़ते ही आपका सिस्टम वह कंटेंट रखता है जो प्रोवाइडर नहीं रखता। इसे यूज़र डेटा के किसी भी दूसरे भंडार की तरह बरतें:

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

[LLM API को संवेदनशील डेटा भेजना](https://broadrouter.com/hi/blog/llm-api-sensitive-data/) उस चेकलिस्ट का बाक़ी हिस्सा कवर करता है।

## कैशिंग दूसरे लागत नियंत्रणों के साथ कैसे फ़िट होती है?

कैशिंग दोहराई गई कॉल हटाती है। अनोखी कॉल के लिए यह कुछ नहीं करती, इसलिए यह दूसरे नियंत्रणों की जगह नहीं, उनके साथ रहती है: [छोटे प्रॉम्प्ट](https://broadrouter.com/hi/blog/reduce-prompt-tokens/), प्रोवाइडर की प्रॉम्प्ट कैशिंग, हर अनुरोध पर `max_tokens` की सीमा, और [LLM API ख़र्च नियंत्रण](https://broadrouter.com/hi/blog/llm-api-spend-control/) वाले बजट और लूप सीमाएँ। बड़े एक बार के जॉब के लिए, भेजने से पहले इनपुट से डुप्लिकेट हटाएँ; यह कैश वाला ही विचार है, एक बार किया हुआ। [Batch API के बिना बड़ा जॉब प्रोसेस करना](https://broadrouter.com/hi/blog/llm-batch-processing-without-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](https://broadrouter.com/hi/guides/openai-python-sdk/) के साथ काम करता है। इसमें अपनी कोई रिस्पॉन्स-कैशिंग सुविधा नहीं है; इस पोस्ट का कैश आपका है। प्रोवाइडर की तरफ़ के कैश हिट `usage.prompt_tokens_details.cached_tokens` में रिपोर्ट होते हैं और कैश्ड इनपुट कीमत पर बिल होते हैं, उसके [API रेफ़रंस](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-cache-llm-responses-cut-cost&utm_content=body) के अनुसार। हर मॉडल की कीमतें [प्राइसिंग पेज](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-cache-llm-responses-cut-cost&utm_content=body) पर हैं।

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

-   [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 इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

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

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

[एम्बेडिंग (embeddings)](https://broadrouter.com/hi/glossary/embeddings/)

एम्बेडिंग, फ़्लोटिंग-पॉइंट संख्याओं की सूचियाँ (वेक्टर) हैं जो कोई मॉडल टेक्स्ट, इमेज या दूसरे इनपुट को दर्शाने के लिए बनाता है। मिलते-जुलते अर्थ वाले इनपुट के वेक्टर पास-पास होते हैं, इसलिए वेक्टर के बीच की दूरी से सर्च नतीजों की रैंकिंग, दस्तावेज़ों का समूह बनाना या जुड़ी चीज़ें ढूँढना संभव होता है।

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

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

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

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

[टेम्परेचर (temperature)](https://broadrouter.com/hi/glossary/temperature/)

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

[वेक्टर डेटाबेस (vector database)](https://broadrouter.com/hi/glossary/vector-database/)

वेक्टर डेटाबेस एक डेटा स्टोर है जो embedding वेक्टर, अक्सर उनके सोर्स टेक्स्ट और मेटाडेटा के साथ, रखता है और nearest-neighbour क्वेरी का जवाब देता है: क्वेरी वेक्टर मिलने पर यह सबसे मिलते-जुलते सेव वेक्टर लौटाता है, आम तौर पर cosine दूरी, Euclidean दूरी या inner product से।

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

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

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

### प्रॉम्प्ट कैशिंग और रिस्पॉन्स कैशिंग में क्या फ़र्क़ है?

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

### क्या temperature 0 पर LLM रिस्पॉन्स कैश करने चाहिए?

हाँ, अगर अनुरोध का कोई साइड इफ़ेक्ट नहीं है और उसे भेजने वाले हर व्यक्ति के लिए एक ही जवाब ठीक है। temperature 0 वैसे भी सर्विंग इंजन से हूबहू एक जैसे आउटपुट की गारंटी नहीं देता, इसलिए कैश जवाब को एक जैसा भी बनाता है। temperature 0 से ऊपर हो या न दिया गया हो, तो कैश न करें।

### LLM रिस्पॉन्स कैशिंग से कितनी बचत होती है?

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

### क्या सिमेंटिक कैशिंग, एक्ज़ैक्ट-मैच कैशिंग से बेहतर है?

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

### क्या स्ट्रीम किए रिस्पॉन्स कैश कर सकते हैं?

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

## आगे पढ़ें

-   [कैश्ड इनपुट टोकन क्या हैं: LLM API का बिल कैसे घटाएँ](https://broadrouter.com/hi/blog/cached-input-tokens-explained/)
-   [प्रॉम्प्ट को कैसे बनाएँ ताकि प्रीफ़िक्स कैश हो](https://broadrouter.com/hi/blog/prompt-structure-for-caching/)
-   [LLM API ख़र्च पर नियंत्रण: बजट, key सीमाएँ और लूप से बचाव](https://broadrouter.com/hi/blog/llm-api-spend-control/)
-   [प्रॉम्प्ट टोकन कैसे घटाएँ: सिस्टम प्रॉम्प्ट, टूल, डेटा की मापी कटौती](https://broadrouter.com/hi/blog/reduce-prompt-tokens/)
-   [LLM API usage लॉगिंग: हर यूज़र और फ़ीचर की लागत, PII हटाकर](https://broadrouter.com/hi/blog/llm-api-usage-logging/)
-   [Batch API के बिना LLM बैच प्रोसेसिंग: दोबारा शुरू होने वाला runner](https://broadrouter.com/hi/blog/llm-batch-processing-without-batch-api/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [डॉक्यूमेंट AI वर्कफ़्लो में ह्यूमन रिव्यू को शामिल करें](https://broadrouter.com/hi/blog/document-review-queues/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: रीज़निंग मॉडल ख़ाली जवाब क्यों लौटाता है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)

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

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-cache-llm-responses-cut-cost&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: रीज़निंग max\_tokens में गिनी जाती है, रीज़निंग और कैश्ड टोकन के usage फ़ील्ड, उपयोग के अनुसार भुगतान की सीमाएँ (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-cache-llm-responses-cut-cost&utm_content=sources)
-   [BroadNet इन्फ़रेंस प्राइवेसी स्टेटमेंट: कोई प्रॉम्प्ट, संदेश, रिस्पॉन्स या ट्रांसक्रिप्ट नहीं रखे जाते; बिना कंटेंट वाले ट्रैफ़िक और usage रिकॉर्ड रखे जाते हैं (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://www.broadnet.ai/inference-privacy)
-   [GitHub पर GPTCache: एम्बेडिंग और सिमिलैरिटी इवैल्युएटर वाला सिमेंटिक कैश, फ़ॉल्स पॉज़िटिव और फ़ॉल्स नेगेटिव, बिना एम्बेडिंग के कीवर्ड-मैचिंग मोड (2026-11-15 को जाँचा गया)](https://github.com/zilliztech/GPTCache)
-   [vLLM डॉक्यूमेंटेशन, Reproducibility: "vLLM does not guarantee the reproducibility of the results by default" (2026-11-15 को जाँचा गया)](https://docs.vllm.ai/en/latest/usage/reproducibility.html)
-   [Python डॉक्यूमेंटेशन, json मॉड्यूल: json.dumps में sort\_keys, separators और ensure\_ascii (2026-11-15 को जाँचा गया)](https://docs.python.org/3/library/json.html)
