BroadRouter

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

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

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

हर एक जैसा 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 जो आप दोबारा चलाते हैं, और डेवलपमेंट लूप जहाँ आप एक ही अनुरोध बार-बार भेजते हैं।

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

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

  1. TTL। हर एंट्री की समय-सीमा: स्थिर FAQ जवाबों के लिए दिन, लाइव डेटा पढ़ने वाली किसी भी चीज़ के लिए मिनट।
  2. key में वर्ज़न। जब सिस्टम प्रॉम्प्ट, रिट्रीवल इंडेक्स या आउटपुट स्कीमा बदले, तो प्रॉम्प्ट वर्ज़न बदलें। पुरानी एंट्री मैच होना बंद कर देती हैं और समय के साथ हट जाती हैं।
  3. 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 रेफ़रंस के अनुसार। हर मॉडल की कीमतें प्राइसिंग पेज पर हैं।

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

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

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

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

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

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

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

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

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

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

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

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

स्रोत