---
title: "I-cache ang LLM API response para makatipid (Python)"
description: "Na-test na exact-match cache para sa LLM API response sa Python: ano ang nasa key, ano ang hindi dapat i-cache, TTL, privacy, at paano sukatin ang hit rate."
url: https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/
lang: fil
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/cache-llm-responses-cut-cost/) (na-update noong 2026-11-15).

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

Ng BroadNet Inference team · 8 minutong basa · Nailathala 2026-11-15

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.

## Mga pangunahing punto

-   Natitipid ng exact cache ang buong call, kasama ang output at reasoning token, pero para lang sa byte-identical na request. Laging miss ang mga tanong na iba ang pagkakasabi.
-   Ilagay sa key ang bawat parameter na nagpapabago sa sagot, dagdag ang prompt version. Kapag may nakaligtaan, maling sagot ang maibabalik; kapag may idinagdag na ingay gaya ng timestamp, magmi-miss ang bawat request.
-   Huwag i-cache ang mga sampled na sagot (temperature na higit sa 0), mga naka-stream na sagot, mga tool call, o mga sagot na naputol sa max\_tokens.
-   Sukatin muna: i-hash ang bawat request sa usage logs mo at bilangin ang mga pag-ulit. Walang sinasabi tungkol sa traffic mo ang mga nakalathalang bilang ng natipid.
-   Nag-iimbak ng mga prompt at sagot ang cache. Kung walang itinatagong inference content ang provider mo, ang cache na ngayon ang kinalalagyan ng content na iyon, kaya bigyan ito ng TTL at mga patakaran sa access.

**Sa page na ito**

1.  Pareho ba ang response caching at prompt caching?
2.  Talaga bang makakatipid ka sa cache?
3.  Ano ang nasa cache key?
4.  Ang cache: SQLite, TTL at skip policy
5.  Ano ang hindi dapat kailanman ibalik mula sa cache?
6.  Kailan dapat mag-expire ang mga naka-cache na sagot?
7.  Paano naman ang semantic caching?
8.  Ano ang ibig sabihin ng cache para sa privacy?
9.  Paano bumabagay ang caching sa ibang kontrol sa gastos?
10.  Saan pumapasok ang BroadNet Inference

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](https://broadrouter.com/fil/blog/cached-input-tokens-explained/) ang panig ng provider, at ipinapakita ng [prompt structure para sa caching](https://broadrouter.com/fil/blog/prompt-structure-for-caching/) kung paano ilatag ang prompt para magamit ulit ang prefix. Kinukuwenta naman ng [prompt caching calculator](https://broadrouter.com/tools/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](https://broadrouter.com/fil/blog/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:

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

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:

```text
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](https://broadrouter.com/fil/models/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](https://broadrouter.com/tools/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

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

At isang run laban dito:

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

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](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/)). 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](https://broadrouter.com/fil/glossary/tool-calling/) 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](https://broadrouter.com/fil/blog/evaluate-llm-before-switching/).

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](https://broadrouter.com/fil/glossary/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](https://broadrouter.com/tools/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](https://www.broadnet.ai/inference-privacy) 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](https://broadrouter.com/fil/blog/llm-api-sensitive-data/) 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](https://broadrouter.com/fil/blog/reduce-prompt-tokens/), 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](https://broadrouter.com/fil/blog/llm-api-spend-control/). 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](https://broadrouter.com/fil/blog/llm-batch-processing-without-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](https://broadrouter.com/fil/guides/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](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-cache-llm-responses-cut-cost&utm_content=body) nito. Nasa [pricing page](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-cache-llm-responses-cut-cost&utm_content=body) ang mga presyo kada model.

Mga libreng tool para rito (Ingles)

-   [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.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[Token](https://broadrouter.com/fil/glossary/token/)

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

[Cached input token (cached input tokens)](https://broadrouter.com/fil/glossary/cached-input-tokens/)

Ang cached input token ay prompt token na kamakailan lang naproseso ng LLM provider at magagamit ulit mula sa cache sa halip na kuwentahin muli, kadalasang paulit-ulit na prefix gaya ng system prompt o dokumento. Mas mababa ang singil dito kaysa sa bagong input token.

[API key](https://broadrouter.com/fil/glossary/api-key/)

Ang API key ay isang lihim na string na kumikilala at nagpapahintulot sa client na tumatawag sa isang API. Kadalasang hinihingi ito ng mga LLM API sa Authorization: Bearer header, at ang sinumang may hawak ng key ay makakagawa ng mga request na sisingilin sa account na may-ari nito.

[Embeddings](https://broadrouter.com/fil/glossary/embeddings/)

Ang embeddings ay mga listahan ng floating-point na numero (vector) na binubuo ng isang model para kumatawan sa isang piraso ng text, larawan o ibang input. Magkakalapit ang vector ng mga input na magkatulad ang kahulugan, kaya magagamit ang layo ng mga vector para i-rank ang search results, i-cluster ang mga dokumento o hanapin ang magkakaugnay na item.

[Input at output token (input and output tokens)](https://broadrouter.com/fil/glossary/input-and-output-tokens/)

Ang input token ay ang mga token na binabasa ng language model sa isang request, kasama ang system prompt, history ng usapan, tool definitions at mga larawan. Ang output token ay ang mga token na binubuo nito bilang sagot, kasama ang anumang reasoning. Kadalasang magkahiwalay ang presyo ng dalawa, at mas mahal ang output.

[Tool calling (function calling)](https://broadrouter.com/fil/glossary/tool-calling/)

Ang tool calling, tinatawag ding function calling, ay feature ng LLM API kung saan nagbabalik ang model ng structured na request para magpatakbo ng function na tinukoy ng developer, kasama ang JSON arguments. Ang application ang nagpapatakbo ng function at nagpapadala pabalik ng resulta; hindi kailanman nagpapatakbo ng code ang model mismo.

[System prompt](https://broadrouter.com/fil/glossary/system-prompt/)

Ang system prompt ay ang instruction na ipinapadala ng isang application sa language model bago ang usapan, kadalasan bilang mensaheng may system o developer role. Itinatakda nito ang role, mga patakaran, tono at format ng output ng model, at dapat itong sundin ng model kahit salungat ang mensahe ng user.

[Vector database](https://broadrouter.com/fil/glossary/vector-database/)

Ang vector database ay isang data store na naglalaman ng mga embedding vector, kadalasang kasama ang source text at metadata, at sumasagot sa nearest-neighbour query: bigyan mo ito ng query vector at ibabalik nito ang mga naka-store na vector na pinakakahawig nito, karaniwang batay sa cosine distance, Euclidean distance o inner product.

## 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.

## Magbasa pa

-   [Cached input token: paano nito binabawasan ang LLM API bill mo](https://broadrouter.com/fil/blog/cached-input-tokens-explained/)
-   [Paano ayusin ang prompt para ma-cache ang prefix](https://broadrouter.com/fil/blog/prompt-structure-for-caching/)
-   [Kontrol sa gastos ng LLM API: budget, limit sa key at loop protection](https://broadrouter.com/fil/blog/llm-api-spend-control/)
-   [Bawasan ang prompt token: sinukat na tipid sa system prompt at tools](https://broadrouter.com/fil/blog/reduce-prompt-tokens/)
-   [Usage logging ng LLM API: gastos kada user at feature, walang PII](https://broadrouter.com/fil/blog/llm-api-usage-logging/)
-   [LLM batch processing nang walang Batch API: resumable na runner](https://broadrouter.com/fil/blog/llm-batch-processing-without-batch-api/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [Gawing bahagi ng document AI workflow mo ang human review](https://broadrouter.com/fil/blog/document-review-queues/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)
-   [Gabay: Bakit walang laman ang sagot ng isang reasoning model](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

[Magsimula](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-cache-llm-responses-cut-cost&utm_content=page-cta) ·

**Mga source**

-   [API reference ng BroadNet Inference: kasama ang reasoning sa max\_tokens, usage field para sa reasoning at cached token, mga limit ng pay-as-you-go (sinuri noong 2026-11-15) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-cache-llm-responses-cut-cost&utm_content=sources)
-   [Inference privacy statement ng BroadNet: walang itinatagong prompt, mensahe, response o transcript; itinatago ang traffic at usage record na walang content (sinuri noong 2026-11-15) (Ingles)](https://www.broadnet.ai/inference-privacy)
-   [GPTCache sa GitHub: semantic cache na may embeddings at similarity evaluator, false positive at false negative, keyword-matching mode na walang embeddings (sinuri noong 2026-11-15)](https://github.com/zilliztech/GPTCache)
-   [Dokumentasyon ng vLLM, Reproducibility: "vLLM does not guarantee the reproducibility of the results by default" (salin: hindi ginagarantiya ng vLLM by default na mauulit ang mga resulta) (sinuri noong 2026-11-15)](https://docs.vllm.ai/en/latest/usage/reproducibility.html)
-   [Dokumentasyon ng Python, json module: sort\_keys, separators at ensure\_ascii sa json.dumps (sinuri noong 2026-11-15)](https://docs.python.org/3/library/json.html)
