BroadRouter

I-cache ang LLM API response, makatipid: exact-match cache sa Python

Ng BroadNet Inference team · 8 minutong basa · Nailathala

I-hash ang buong request (model, messages, temperature, max_tokens, response_format, tools, reasoning settings at ang prompt version mo) bilang key, at iimbak ang sagot sa ilalim nito na may expiry. Magbalik lang ng naka-store na sagot para sa mga deterministic na request na walang side effect. Sukatin muna sa logs mo kung gaano kadalas umuulit ang magkaparehong request: iyon ang pinakamalaking matitipid ng exact cache.

Dalawang beses mong binabayaran ang bawat magkaparehong LLM request na ipinapadala mo nang dalawang beses. Iniimbak ng response cache ang sagot sa unang pagkakataon at ibinabalik ito sa susunod, walang token na sinisingil at walang paghihintay. Simple ang ideya. Ang mahihirap na bahagi ay ang pagpapasya kung ano ang nagpapa-”magkapareho” sa dalawang request, aling mga request ang hindi dapat kailanman ibalik mula sa storage, at kung sapat ba ang pag-ulit ng traffic mo para magkaroon ito ng saysay.

Bumubuo ang post na ito ng maliit na exact-match cache sa Python gamit ang SQLite, na-test laban sa isang mock na OpenAI-compatible na server, at ipinapakita kung paano sukatin ang hit rate mula sa logs mo bago ka magsulat ng kahit ano.

Pareho ba ang response caching at prompt caching?

Hindi. Magkaibang bagay ang natitipid nila, at puwede mong gamitin ang dalawa.

Prompt caching (provider) Response caching (ikaw)
Ano ang ginagamit ulit Ang paulit-ulit na simula ng prompt Ang buong sagot
Sino ang nagpapatakbo Ang API provider Ang code mo
Tumatakbo pa rin ang model? Oo, bagong sagot ang isinusulat Hindi
Ano ang natitipid Bahagi ng gastos sa input Input, output at reasoning token, dagdag ang latency
Kailan tumatama Shared na prefix, ibang tanong Eksaktong parehong request

Ipinapaliwanag ng cached input token ang panig ng provider, at ipinapakita ng prompt structure para sa caching kung paano ilatag ang prompt para magamit ulit ang prefix. Kinukuwenta naman ng prompt caching calculator ang presyo nito. Nasa harap ng lahat ng iyon ang response cache: kapag may hit, walang request na lumalabas sa server mo.

Talaga bang makakatipid ka sa cache?

Sukatin bago bumuo. Galing sa traffic ng iba ang mga percentage ng natipid sa maraming caching tutorial. Iisang bagay lang ang pinagbabatayan ng numero mo: gaano kadalas dumarating ulit ang parehong request sa loob ng expiry window mo.

Kung nila-log mo na ang bawat call, gaya ng sa LLM API usage logging, magdagdag ng isang field: request_hash, ang cache key na inilalarawan sa ibaba. Walang text ng prompt na iniimbak ito, kaya bagay ito sa log na walang content. Pagkatapos, bilangin ang mga pag-ulit:

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%}")

Sa isang synthetic na log ng 20 call, isang request na limang beses, isa pa na tatlong beses at labindalawang natatangi, nag-print ito ng potential hit rate na 30.0%. Pinakamataas na posibleng bilang iyon: hindi nito isinasaalang-alang ang expiry, at inaakala nitong ligtas ibalik mula sa storage ang bawat pag-ulit.

Pagkatapos, gawing pera ang rate:

monthly saving = hit rate × requests per month
                 × (input tokens × input price + output tokens × output price) ÷ 1,000,000

Kasama ang reasoning sa mga output token. Sinasabi ng docs ng BroadNet na nagre-reason ang DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B bago sumagot at na kasama ang reasoning sa max_tokens, kaya natitipid ng isang hit ang mga token na hindi mo nakikita sa sagot. Kunin ang completion_tokens mula sa naka-log na usage, hindi sa haba ng sagot.

Isang halimbawang kuwenta sa token: 100,000 request kada buwan na tig-1,200 input at 150 output token, na may 30% hit rate, ay nakakaiwas sa 36 milyong input token at 4.5 milyong output token. Sa DeepSeek V4.1 Flash, sinisingil ang mga iyon sa $0.175 at $0.52 kada 1M ayon sa pagkakasunod; ilagay ang sarili mong mga numero sa LLM API cost calculator. Kung provider cache hit na ang karamihan ng input na iyon, nasa mas mababang cached rate ang matitipid sa input ($0.0055 kada 1M sa parehong model), kaya kadalasan ang output ang mas mahalaga.

Ano ang nasa cache key?

Lahat ng puwedeng magpabago sa sagot, at wala nang iba.

  • Isama: model, ang buong messages na listahan (kasama ang system prompt), temperature, top_p, max_tokens, seed, response_format, tools, tool_choice at reasoning_effort.
  • Magdagdag ng prompt version na kontrolado mo, gaya ng faq-v3. Itaas ito kapag binago mo ang mga prompt template, retrieval data o post-processing na hindi nakikita sa request body.
  • Huwag isama ang anumang nag-iiba kada call nang hindi binabago ang sagot: mga request ID, timestamp, trace header, isang user field na ipinapadala mo lang para sa abuse tracking.

I-serialize ang key material sa parehong paraan sa bawat pagkakataon. Ang json.dumps ng Python na may sort_keys=True at separators=(",", ":") ay nagbibigay ng iisang canonical na string anuman ang ayos ng dictionary; pinapanatili ng ensure_ascii=False ang Arabic at iba pang hindi Latin na text bilang UTF-8 imbes na escape. I-hash ito gamit ang SHA-256.

Ang nawawalang field ang mapanganib na pagkakamali. Kung wala sa key ang max_tokens, maibabalik ang sagot na naputol sa maliit na limit sa isang request na nagpahintulot ng mahaba.

Ang cache: SQLite, TTL at skip policy

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

At isang run laban dito:

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}")

Pinatakbo namin ito gamit ang OpenAI Python SDK 3.51.0 laban sa isang lokal na mock server na nagbilang ng mga upstream call at nag-ulat ng 1,200 prompt at 150 completion token kada sagot (walang live na API call). Apat na upstream call ang ginawa ng pitong request. Nag-print ang script ng hits=3 misses=3 skipped=1 saved_input=3600 saved_output=450. Nang patakbuhin ulit sa parehong database file, hit ang lahat ng anim na cacheable na request (hits=6 misses=0): pinapanatili ng SQLite ang cache kahit mag-restart. Nagtugma ang mga key na binuo mula sa parehong mga field sa ibang ayos.

Mga tala sa code:

  • Ang max_tokens=1200 ay nag-iiwan ng puwang para sa reasoning bago ang sagot. Kapag maliit ang limit, puwedeng magbalik ng walang laman na sagot ang isang reasoning model (bakit). Hindi iniimbak ang mga sagot na iyon, dahil length ang finish_reason, hindi stop.
  • Dict ang ibinabalik ng mga hit. model_dump() din ang ibinabalik ng mga miss, kaya iisang hugis ang nakikita ng mga caller. Kung SDK object ang inaasahan ng code mo, balutin ang dalawa.
  • Itinuturing na sampled ang walang temperature. Sariling default ng server ang ilalapat noon, na puwedeng higit sa 0, kaya nilalaktawan ng wrapper ang caching maliban kung tahasan mong itinakda sa 0.
  • Bagay ang SQLite sa isa o ilang process. Para sa maraming server, ilagay ang parehong key at TTL logic sa Redis o sa database mo.

Ano ang hindi dapat kailanman ibalik mula sa cache?

  • Mga sampled na sagot (temperature na higit sa 0). Pinili mo ang pagkakaiba-iba. Inaalis iyon ng caching, at parehong text ang makukuha ng user na pumipindot ng “regenerate”.
  • Mga personalized na sagot, maliban kung nasa key ang user ID. Magkaiba ang account ng dalawang user na nagpapadala ng “summarise my account”. Mas mabuti: i-cache lang ang mga request na walang per-user na data sa mga mensahe.
  • Mga tool call. Ang tool call ay utos na kumilos. Kapag ni-replay mula sa storage ang “refund order 1182”, puwedeng maulit ang isang side effect, at nakadepende sa kasalukuyang estado ang tamang susunod na hakbang. Tumatanggi ang wrapper na mag-imbak ng anumang sagot na may tool_calls.
  • Mga naka-stream na sagot. Nilalampasan ng wrapper ang cache para sa stream=True. Ang pag-cache ng stream ay nangangahulugang i-buffer ito, tiyaking natapos ito, at i-replay ito, na bihirang sulit para sa mga chat UI.
  • Mga naputol o pumalyang sagot. Iimbak lang ang finish_reason == "stop". Ang naputol na sagot o error na naka-cache nang isang linggo ay bug na mukhang problema ng model.
  • Mga sagot na nakadepende sa oras. Kailangan ng “What is today’s exchange rate?” ng maikling TTL o walang cache.

Ang mga bagay na mahusay i-cache: classification ng fixed na set ng input, extraction mula sa mga dokumentong pinoproseso mo ulit, mga FAQ na sagot mula sa fixed na prompt, mga test suite at eval na pinapatakbo mo ulit, at mga development loop kung saan paulit-ulit mong ipinapadala ang parehong request.

Kailan dapat mag-expire ang mga naka-cache na sagot?

Gumamit ng tatlong uri ng invalidation:

  1. TTL. Limit sa oras kada entry: ilang araw para sa mga stable na FAQ na sagot, ilang minuto para sa anumang nagbabasa ng live na data.
  2. Version sa key. Palitan ang prompt version kapag nagbago ang system prompt, retrieval index o output schema. Hindi na magtutugma ang mga lumang entry at unti-unti silang mag-e-expire.
  3. Model sa key. Naroon na ito, kaya kapag lumipat ka mula sa isang model papunta sa iba, bagong cache ang magsisimula, na siyang gusto mo habang ine-evaluate ang paglipat.

Burahin ang mga expired na row ayon sa iskedyul (DELETE FROM cache WHERE created < ?). Kung hindi, lalaki lang nang lalaki ang file.

May karagdagang pakinabang. Hindi nangangako ang mga serving engine ng magkaparehong output para sa magkaparehong input: sinasabi ng dokumentasyon ng vLLM na “does not guarantee the reproducibility of the results by default” (salin: hindi nito ginagarantiya by default na mauulit ang mga resulta). Binibigyan ng cache ang bawat user ng parehong sagot sa parehong tanong habang buhay ang entry.

Paano naman ang semantic caching?

Ine-embed ng semantic cache ang bawat tanong at nagbabalik ng naka-store na sagot kapag sapat na malapit ang bagong tanong, kaya puwedeng tumama ang “how long is a refund?” sa “how long do refunds take?”. Ang GPTCache ang pinakakilalang open-source na halimbawa. Sinasabi ng README nito na gumagamit ito ng vector store para sa similarity search at ng similarity evaluator para magpasya kung hit, nagbababala na “you may encounter false positives during cache hits and false negatives during cache misses” (salin: puwede kang makatagpo ng false positive sa mga cache hit at false negative sa mga cache miss), at binabanggit na nagiging keyword-matching cache ito kapag in-disable ang embeddings.

Dalawang praktikal na punto. Una, kailangan nito ng embeddings model at vector store. Hindi nag-aalok ng embeddings ang BroadNet Inference, kaya ibang provider o lokal na model ang gagamitin mo para sa layer na iyon; kinukuwenta ng embedding cost calculator ang presyo ng mga opsyon. Pangalawa, nagbabalik ang maling hit ng kumpiyansang sagot sa ibang tanong. Gumamit ng mahigpit na similarity threshold, i-test ito sa mga totoong pares na halos magkatugma, at gamitin lang ang semantic caching sa mga sagot na mababa ang nakataya. Ilagay pa rin sa harap ang exact cache: libre itong suriin at hindi kailanman nagkakamali sa kung ano ang itinanong.

Ano ang ibig sabihin ng cache para sa privacy?

Ang cache ay imbakan ng mga prompt at sagot. Binabago nito kung saan nakatira ang data mo.

Sinasabi ng inference privacy statement ng BroadNet, sinuri noong 2026-11-15, na walang itinatagong prompt, mensahe, response o transcript ang gateway nito, habang itinatago ang traffic at usage record na walang content (bilang ng token, gastos, timing). Hindi itinatago ang inference content. Itinatago ang kinakailangang metadata ng account, billing at security ayon sa inilalarawan ng statement na iyon. Kapag nagdagdag ka ng response cache, hawak na ng system mo ang content na hindi hawak ng provider. Ituring ito gaya ng anumang imbakan ng data ng user:

  • Hangga’t maaari, i-cache lang ang mga request na walang personal na data, na nagpapataas din ng hit rate.
  • Magtakda ng TTL na sapat na maikli para sa retention policy mo, at magbura ayon sa iskedyul.
  • I-encrypt ang file o table at rest at limitahan kung sino ang makakabasa nito.
  • Isama ang cache sa mga request na magbura ng data kung puwede itong maglaman ng text ng user.

Sinasaklaw ng pagpapadala ng sensitibong data sa LLM API ang natitirang bahagi ng checklist na iyon.

Paano bumabagay ang caching sa ibang kontrol sa gastos?

Inaalis ng caching ang mga paulit-ulit na call. Wala itong nagagawa sa mga natatangi, kaya katabi ito ng ibang kontrol at hindi kapalit: mas maiikling prompt, prompt caching ng provider, max_tokens na limit kada request, at mga budget at limit sa loop mula sa kontrol sa gastos ng LLM API. Para sa malalaking isahang job, i-deduplicate ang mga input bago mo ipadala; parehong ideya iyon ng cache, ginawa nang isang beses. Ipinapakita ng pagproseso ng malaking job nang walang Batch API ang panig ng job.

Sa isang flat-rate na plan, nagbabago ang kuwenta. Walang token meter ang mga DeepSeek session ng BroadNet, kaya walang perang natitipid ang cache hit doon. Nakakatipid pa rin ito ng oras: isang request sa bawat pagkakataon ang tinatakbo ng isang session, kaya bawat pag-ulit na nalalaktawan mo ay nagpapaluwag sa session para sa bagong trabaho.

Saan pumapasok ang BroadNet Inference

Ang BroadRouter ay sariling site ng BroadNet. Inilalantad ng BroadNet Inference ang DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B at Gemma 4 VL 26B sa likod ng isang OpenAI-compatible na /v1/chat/completions endpoint, kaya gumagana ang wrapper sa itaas sa OpenAI Python SDK sa pagpapalit lang ng base URL. Wala itong sariling response-caching na feature; iyo ang cache sa post na ito. Iniuulat ang mga cache hit sa panig ng provider sa usage.prompt_tokens_details.cached_tokens at sinisingil sa presyo ng cached input, ayon sa API reference nito. Nasa pricing page ang mga presyo kada model.

Mga tanong

Ano ang pagkakaiba ng prompt caching at response caching?

Ang provider ang gumagawa ng prompt caching: sinisingil sa mas mababang cached-input na presyo ang paulit-ulit na prompt prefix, at bagong sagot pa rin ang isinusulat ng model. Ikaw ang gumagawa ng response caching: iniimbak mo ang buong sagot at ibinabalik ito para sa magkaparehong request nang hindi na tinatawag ang model.

Dapat ko bang i-cache ang LLM response sa temperature 0?

Oo, kung walang side effect ang request at katanggap-tanggap ang parehong sagot para sa lahat ng nagpapadala nito. Hindi naman ginagarantiya ng temperature 0 na magkapareho ang output mula sa isang serving engine, kaya ginagawa ring consistent ng cache ang sagot. Huwag mag-cache kapag higit sa 0 o walang nakatakdang temperature.

Magkano ang natitipid sa LLM response caching?

Ang bahagi ng mga request na eksaktong pag-ulit sa loob ng expiry window mo, na-multiply sa gastos ng mga request na iyon. Bilangin ang mga paulit-ulit na request hash sa sarili mong logs para makuha ang bahaging iyon. Puwede itong halos zero para sa open-ended na chat at mataas para sa fixed na FAQ o classification input.

Mas mahusay ba ang semantic caching kaysa sa exact-match caching?

Mas madalas itong tumama, dahil nagtutugma ang magkakahawig na tanong, pero puwede itong magbalik ng sagot sa ibang tanong. Kailangan din nito ng embeddings model at vector store. Magsimula sa exact cache, at magdagdag lang ng semantic layer kung saan mura ang maling hit.

Puwede ko bang i-cache ang mga naka-stream na response?

Hindi gamit ang simpleng wrapper dito. Kailangan mong kolektahin ang buong stream, tiyaking natapos ito nang normal, iimbak ito, at i-replay ito bilang stream sa susunod. Karamihan ng team ay nagca-cache lang ng mga hindi naka-stream na call gaya ng classification, extraction at FAQ na sagot.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity