---
title: "Cache respons API LLM untuk hemat biaya (Python, SQLite)"
description: "Exact-match cache teruji untuk respons API LLM di Python: isi cache key, apa yang tidak boleh di-cache, TTL, privasi, dan cara mengukur hit rate lebih dulu."
url: https://broadrouter.com/id/blog/cache-llm-responses-cut-cost/
lang: id
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Diterjemahkan dari bahasa Inggris dengan bantuan AI. [Baca versi asli bahasa Inggris](https://broadrouter.com/blog/cache-llm-responses-cut-cost/) (diperbarui 2026-11-15).

# Cache respons API LLM untuk memangkas biaya: exact cache di Python

Oleh tim BroadNet Inference · 8 menit baca · Dipublikasikan 2026-11-15

Hash seluruh permintaan (model, messages, temperature, max\_tokens, response\_format, tools, pengaturan penalaran, dan versi prompt Anda) menjadi sebuah key, lalu simpan jawabannya di bawah key itu dengan masa kedaluwarsa. Sajikan jawaban tersimpan hanya untuk permintaan yang deterministik dan tanpa efek samping. Ukur dulu seberapa sering permintaan identik berulang di log Anda: porsi itulah batas maksimal yang bisa dihemat exact cache.

## Poin penting

-   Exact cache menghemat seluruh panggilan, termasuk token output dan penalaran, tetapi hanya untuk permintaan yang identik byte demi byte. Pertanyaan dengan kata-kata berbeda selalu miss.
-   Masukkan setiap parameter yang mengubah jawaban ke dalam key, ditambah versi prompt. Melewatkan satu saja akan menyajikan jawaban yang salah; menambahkan noise seperti timestamp membuat setiap permintaan miss.
-   Jangan cache balasan hasil sampling (temperature di atas 0), balasan streaming, tool call, atau jawaban yang terpotong di max\_tokens.
-   Ukur dulu: hash setiap permintaan di log pemakaian dan hitung pengulangannya. Angka penghematan yang dipublikasikan pihak lain tidak mengatakan apa pun tentang trafik Anda.
-   Cache menyimpan prompt dan jawaban. Jika penyedia Anda tidak menyimpan konten inferensi, kini cache-lah tempat konten itu berada, jadi beri TTL dan aturan akses.

**Di halaman ini**

1.  Apakah response caching sama dengan prompt caching?
2.  Apakah cache benar-benar menghemat uang?
3.  Apa yang dimasukkan ke cache key?
4.  Cache-nya: SQLite, TTL, dan kebijakan skip
5.  Apa yang tidak boleh disajikan dari cache?
6.  Kapan jawaban yang di-cache sebaiknya kedaluwarsa?
7.  Bagaimana dengan semantic caching?
8.  Apa arti cache bagi privasi?
9.  Bagaimana caching berdampingan dengan kontrol biaya lain?
10.  Posisi BroadNet Inference

Setiap permintaan LLM identik yang Anda kirim dua kali dibayar dua kali. Response cache menyimpan jawaban pada kali pertama dan mengembalikannya pada kali berikutnya, tanpa token yang ditagih dan tanpa menunggu. Idenya sederhana. Bagian sulitnya adalah menentukan apa yang membuat dua permintaan “identik”, permintaan mana yang tidak boleh disajikan dari penyimpanan, dan apakah trafik Anda cukup sering berulang sampai berarti.

Artikel ini membangun exact-match cache kecil di Python dengan SQLite, diuji terhadap server tiruan yang kompatibel dengan OpenAI, dan menunjukkan cara mengukur hit rate dari log Anda sebelum menulis satu baris pun.

## Apakah response caching sama dengan prompt caching?

Tidak. Keduanya menghemat hal yang berbeda, dan Anda bisa memakai keduanya.

|  | Prompt caching (penyedia) | Response caching (Anda) |
| --- | --- | --- |
| Yang dipakai ulang | Bagian awal prompt yang berulang | Seluruh jawaban |
| Siapa yang menjalankan | Penyedia API | Kode Anda |
| Model tetap berjalan? | Ya, menulis jawaban baru | Tidak |
| Yang dihemat | Sebagian biaya input | Token input, output, dan penalaran, plus latensi |
| Kapan hit | Prefiks sama, pertanyaan berbeda | Permintaan yang persis sama |

[Token input cache](https://broadrouter.com/id/blog/cached-input-tokens-explained/) menjelaskan sisi penyedia, dan [struktur prompt untuk caching](https://broadrouter.com/id/blog/prompt-structure-for-caching/) menunjukkan cara menyusun prompt agar prefiksnya dipakai ulang. [Kalkulator prompt caching](https://broadrouter.com/tools/prompt-caching-calculator/) menghitung harganya. Response cache berada di depan semua itu: saat hit, tidak ada permintaan yang keluar dari server Anda.

## Apakah cache benar-benar menghemat uang?

Ukur sebelum membangun. Persentase penghematan di banyak tutorial caching berasal dari trafik orang lain. Angka Anda bergantung pada satu hal: seberapa sering permintaan yang sama datang lagi dalam jendela kedaluwarsa Anda.

Jika Anda sudah mencatat setiap panggilan, seperti di [pencatatan pemakaian API LLM](https://broadrouter.com/id/blog/llm-api-usage-logging/), tambahkan satu field: `request_hash`, yaitu cache key yang dijelaskan di bawah. Field ini tidak menyimpan teks prompt, jadi cocok untuk log yang tidak menyimpan konten. Lalu hitung pengulangannya:

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

Pada log sintetis berisi 20 panggilan, satu permintaan lima kali, satu lagi tiga kali, dan dua belas unik, skrip ini mencetak potensi hit rate 30,0%. Itu batas atas: mengabaikan kedaluwarsa, dan mengasumsikan setiap pengulangan aman disajikan dari penyimpanan.

Lalu ubah rate itu menjadi uang:

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

Artinya: penghematan bulanan = hit rate × permintaan per bulan × (token input × harga input + token output × harga output) ÷ 1.000.000.

Token output sudah termasuk penalaran. Dokumentasi BroadNet menyebut DeepSeek V4.1 Flash, GLM 5.3, dan Qwen3.8 27B bernalar sebelum menjawab dan penalaran dihitung dalam `max_tokens`, jadi satu hit menghemat token yang tidak pernah Anda lihat di balasan. Ambil `completion_tokens` dari `usage` yang dicatat, bukan dari panjang jawaban.

Contoh hitungan dalam token: 100.000 permintaan per bulan masing-masing 1.200 token input dan 150 token output, dengan hit rate 30%, menghindari 36 juta token input dan 4,5 juta token output. Di [DeepSeek V4.1 Flash](https://broadrouter.com/id/models/deepseek-v4.1-flash/), keduanya ditagih masing-masing $0.175 dan $0.52 per 1 juta; masukkan angka Anda sendiri ke [kalkulator biaya API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/). Jika sebagian besar input itu sebenarnya sudah kena cache penyedia, penghematan inputnya dihitung dengan tarif input cache yang lebih rendah ($0.0055 per 1 juta di model yang sama), jadi sisi output sering kali yang lebih berarti.

## Apa yang dimasukkan ke cache key?

Semua yang bisa mengubah jawaban, dan tidak ada yang lain.

-   **Masukkan:** `model`, seluruh daftar `messages` (termasuk system prompt), `temperature`, `top_p`, `max_tokens`, `seed`, `response_format`, `tools`, `tool_choice`, dan `reasoning_effort`.
-   **Tambahkan versi prompt** yang Anda kendalikan, misalnya `faq-v3`. Naikkan versinya saat Anda mengubah template prompt, data retrieval, atau post-processing yang tidak terlihat di body permintaan.
-   **Keluarkan** apa pun yang berubah per panggilan tanpa mengubah jawaban: ID permintaan, timestamp, header tracing, field `user` yang hanya Anda kirim untuk pelacakan penyalahgunaan.

Serialisasi materi key dengan cara yang sama setiap kali. `json.dumps` di Python dengan `sort_keys=True` dan `separators=(",", ":")` menghasilkan satu string kanonik apa pun urutan dictionary-nya; `ensure_ascii=False` menjaga teks Arab dan teks non-Latin lainnya tetap UTF-8, bukan escape. Hash dengan SHA-256.

Field yang terlewat adalah kesalahan yang berbahaya. Jika `max_tokens` tidak ada di key, balasan yang terpotong karena batas kecil akan disajikan untuk permintaan yang mengizinkan jawaban panjang.

## Cache-nya: SQLite, TTL, dan kebijakan skip

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

Dan contoh menjalankannya:

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

Kami menjalankan ini dengan OpenAI Python SDK 3.51.0 terhadap server tiruan lokal yang menghitung panggilan upstream dan melaporkan 1.200 token prompt dan 150 token completion per balasan (tanpa panggilan API sungguhan). Tujuh permintaan menghasilkan empat panggilan upstream. Skripnya mencetak `hits=3 misses=3 skipped=1 saved_input=3600 saved_output=450`. Saat dijalankan lagi pada file database yang sama, keenam permintaan yang bisa di-cache semuanya hit (`hits=6 misses=0`): SQLite menyimpan cache melewati restart. Key yang dibangun dari field yang sama dengan urutan berbeda tetap cocok.

Catatan tentang kodenya:

-   **`max_tokens=1200`** menyisakan ruang untuk penalaran sebelum jawaban. Dengan batas kecil, model penalaran bisa mengembalikan balasan kosong ([kenapa](https://broadrouter.com/id/guides/reasoning-tokens-empty-response/)). Balasan seperti itu tidak disimpan, karena `finish_reason`\-nya `length`, bukan `stop`.
-   **Hit mengembalikan dict.** Miss juga mengembalikan `model_dump()`, jadi pemanggil melihat satu bentuk yang sama. Jika kode Anda mengharapkan objek SDK, bungkus keduanya.
-   **`temperature` yang tidak diisi dianggap sampling.** Server lalu menerapkan default-nya sendiri, yang bisa di atas 0, jadi wrapper melewati caching kecuali Anda mengatur 0 secara eksplisit.
-   **SQLite cocok untuk satu atau beberapa proses.** Untuk beberapa server, taruh logika key dan TTL yang sama di Redis atau database Anda.

## Apa yang tidak boleh disajikan dari cache?

-   **Balasan hasil sampling (temperature di atas 0).** Anda sengaja memilih variasi. Caching menghilangkannya, dan pengguna yang menekan “regenerate” mendapat teks yang sama.
-   **Jawaban yang dipersonalisasi**, kecuali ID pengguna ada di key. Dua pengguna yang mengirim “ringkas akun saya” punya akun yang berbeda. Lebih baik: cache hanya permintaan yang pesannya tidak berisi data per pengguna.
-   **Tool call.** [Tool call](https://broadrouter.com/id/glossary/tool-calling/) adalah instruksi untuk bertindak. Memutar ulang “refund pesanan 1182” dari penyimpanan bisa mengulang efek samping, dan langkah selanjutnya yang benar bergantung pada kondisi saat ini. Wrapper menolak menyimpan balasan apa pun yang berisi `tool_calls`.
-   **Balasan streaming.** Wrapper melewati cache untuk `stream=True`. Meng-cache stream berarti mem-buffer-nya, memastikan selesai, lalu memutarnya ulang, yang jarang sepadan untuk UI chat.
-   **Balasan yang terpotong atau gagal.** Simpan hanya `finish_reason == "stop"`. Jawaban yang terpotong atau error yang ter-cache selama seminggu adalah bug yang terlihat seperti masalah model.
-   **Jawaban yang bergantung pada waktu.** “Berapa kurs hari ini?” butuh TTL pendek atau tanpa cache sama sekali.

Yang cocok di-cache: klasifikasi atas sekumpulan input yang tetap, ekstraksi dari dokumen yang Anda proses ulang, jawaban FAQ dari prompt yang tetap, test suite dan eval yang Anda jalankan ulang, serta loop pengembangan di mana Anda mengirim permintaan yang sama berulang kali.

## Kapan jawaban yang di-cache sebaiknya kedaluwarsa?

Pakai tiga jenis invalidasi:

1.  **TTL.** Batas waktu per entri: hitungan hari untuk jawaban FAQ yang stabil, hitungan menit untuk apa pun yang membaca data live.
2.  **Versi di dalam key.** Ganti versi prompt saat system prompt, indeks retrieval, atau skema output berubah. Entri lama berhenti cocok dan kedaluwarsa dengan sendirinya.
3.  **Model di dalam key.** Sudah ada di sana, jadi berpindah dari satu model ke model lain memulai cache baru, dan itulah yang Anda inginkan saat [mengevaluasi pergantian model](https://broadrouter.com/id/blog/evaluate-llm-before-switching/).

Hapus baris yang kedaluwarsa secara terjadwal (`DELETE FROM cache WHERE created < ?`). Kalau tidak, file-nya hanya akan terus membesar.

Ada manfaat sampingan. Serving engine tidak menjanjikan output identik untuk input identik: dokumentasi vLLM menyebut vLLM “does not guarantee the reproducibility of the results by default” (Terjemahan BroadRouter: secara default tidak menjamin hasil yang dapat direproduksi). Cache memberi setiap pengguna jawaban yang sama untuk pertanyaan yang sama selama entri itu berlaku.

## Bagaimana dengan semantic caching?

Semantic cache mengubah setiap pertanyaan menjadi embedding dan mengembalikan jawaban tersimpan saat pertanyaan baru cukup mirip, sehingga “berapa lama refund?” bisa kena “berapa lama proses refund?”. GPTCache adalah contoh open-source yang paling dikenal. README-nya menyebut GPTCache memakai vector store untuk pencarian kemiripan dan similarity evaluator untuk memutuskan hit, memperingatkan bahwa “you may encounter false positives during cache hits and false negatives during cache misses” (Terjemahan BroadRouter: Anda mungkin menemui false positive saat cache hit dan false negative saat cache miss), dan mencatat bahwa menonaktifkan embedding mengubahnya menjadi cache keyword matching.

Dua poin praktis. Pertama, cara ini butuh model [embedding](https://broadrouter.com/id/glossary/embeddings/) dan vector store. BroadNet Inference tidak menyediakan embedding, jadi Anda perlu penyedia lain atau model lokal untuk lapisan itu; [kalkulator biaya embedding](https://broadrouter.com/tools/embedding-cost-calculator/) menghitung harga pilihannya. Kedua, hit yang keliru mengembalikan jawaban yang meyakinkan untuk pertanyaan yang berbeda. Pakai ambang kemiripan yang ketat, uji pada pasangan pertanyaan nyata yang nyaris mirip, dan batasi semantic caching untuk jawaban berisiko rendah. Bagaimanapun, taruh exact cache di depan: gratis untuk dicek dan tidak pernah salah soal apa yang ditanyakan.

## Apa arti cache bagi privasi?

Cache adalah tempat penyimpanan prompt dan jawaban. Itu mengubah di mana data Anda berada.

[Pernyataan privasi inferensi](https://www.broadnet.ai/inference-privacy) BroadNet, dicek 2026-11-15, menyebut gateway-nya tidak menyimpan prompt, pesan, respons, atau transkrip, sementara catatan trafik dan pemakaian tanpa konten (jumlah token, biaya, waktu) disimpan. Konten inferensi tidak disimpan. Metadata akun, penagihan, dan keamanan yang diperlukan disimpan sebagaimana dijelaskan pernyataan itu. Begitu Anda menambahkan response cache, sistem Anda menyimpan konten yang tidak disimpan penyedia. Perlakukan cache seperti penyimpanan data pengguna lainnya:

-   Sebisa mungkin, cache hanya permintaan tanpa data pribadi; ini juga menaikkan hit rate.
-   Atur TTL yang cukup pendek sesuai kebijakan retensi Anda, dan hapus secara terjadwal.
-   Enkripsi file atau tabelnya saat tersimpan (at rest) dan batasi siapa yang bisa membacanya.
-   Sertakan cache dalam permintaan penghapusan data jika cache bisa berisi teks pengguna.

[Mengirim data sensitif ke API LLM](https://broadrouter.com/id/blog/llm-api-sensitive-data/) membahas sisa checklist tersebut.

## Bagaimana caching berdampingan dengan kontrol biaya lain?

Caching menghilangkan panggilan yang berulang. Caching tidak berpengaruh pada panggilan yang unik, jadi posisinya di samping kontrol lain, bukan menggantikannya: [prompt yang lebih pendek](https://broadrouter.com/id/blog/reduce-prompt-tokens/), prompt caching dari penyedia, batas `max_tokens` per permintaan, serta anggaran dan batas loop dari [kontrol biaya API LLM](https://broadrouter.com/id/blog/llm-api-spend-control/). Untuk job besar sekali jalan, hapus duplikat input sebelum mengirimnya; idenya sama dengan cache, hanya dilakukan sekali. [Memproses job besar tanpa Batch API](https://broadrouter.com/id/blog/llm-batch-processing-without-batch-api/) menunjukkan sisi job-nya.

Di paket harga tetap, hitungannya berubah. Sesi DeepSeek di BroadNet tidak punya meteran token, jadi cache hit tidak menghemat uang di sana. Tetapi tetap menghemat waktu: satu sesi menjalankan satu permintaan dalam satu waktu, jadi setiap pengulangan yang Anda lewati membebaskan sesi untuk pekerjaan baru.

## Posisi BroadNet Inference

BroadRouter adalah situs milik BroadNet sendiri. BroadNet Inference menyediakan DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B, dan Gemma 4 VL 26B di balik endpoint `/v1/chat/completions` yang kompatibel dengan OpenAI, jadi wrapper di atas bekerja dengan [OpenAI Python SDK](https://broadrouter.com/id/guides/openai-python-sdk/) cukup dengan mengganti base URL. BroadNet tidak punya fitur response caching sendiri; cache di artikel ini milik Anda. Cache hit di sisi penyedia dilaporkan di `usage.prompt_tokens_details.cached_tokens` dan ditagih dengan harga input cache, menurut [referensi API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-cache-llm-responses-cut-cost&utm_content=body)\-nya. Harga per model ada di [halaman harga](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-cache-llm-responses-cut-cost&utm_content=body).

Alat gratis untuk topik ini (bahasa Inggris)

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

[Alat gratis (bahasa Inggris)](https://broadrouter.com/tools/)

## Istilah dalam artikel ini

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

Token adalah satuan teks yang dibaca dan ditulis model bahasa: sebuah kata, bagian kata, tanda baca, atau urutan byte yang dihasilkan tokenizer model. API LLM menghitung, membatasi, dan biasanya menagih pemakaian dalam token.

[Token input cache (cached input tokens)](https://broadrouter.com/id/glossary/cached-input-tokens/)

Token input cache adalah token prompt yang baru saja diproses penyedia LLM dan bisa dipakai ulang dari cache alih-alih dihitung lagi, biasanya prefiks berulang seperti system prompt atau dokumen. Penyedia menagihnya dengan tarif lebih rendah daripada token input baru.

[Token input dan output](https://broadrouter.com/id/glossary/input-and-output-tokens/)

Token input adalah token yang dibaca model bahasa dalam sebuah permintaan, termasuk system prompt, riwayat percakapan, definisi tool, dan gambar. Token output adalah token yang dihasilkannya sebagai balasan, termasuk penalaran. API LLM biasanya menghargainya secara terpisah, dan output biasanya lebih mahal.

[Embeddings (vektor embedding)](https://broadrouter.com/id/glossary/embeddings/)

Embeddings adalah daftar angka floating-point (vektor) yang dihasilkan model untuk merepresentasikan sepotong teks, gambar, atau input lain. Input dengan makna serupa mendapat vektor yang berdekatan, sehingga jarak antarvektor bisa dipakai untuk mengurutkan hasil pencarian, mengelompokkan dokumen, atau menemukan item terkait.

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

System prompt adalah teks instruksi yang dikirim aplikasi ke model bahasa sebelum percakapan, biasanya sebagai pesan dengan peran system atau developer. System prompt menetapkan peran, aturan, gaya bahasa, dan format output model, dan model dirancang untuk mengikutinya di atas pesan pengguna yang bertentangan.

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

Tool calling, disebut juga function calling, adalah fitur API LLM di mana model mengembalikan permintaan terstruktur untuk menjalankan fungsi yang didefinisikan developer, lengkap dengan argumen JSON. Aplikasi yang menjalankan fungsi itu dan mengirim hasilnya kembali; model tidak pernah menjalankan kode sendiri.

[Vector database (basis data vektor)](https://broadrouter.com/id/glossary/vector-database/)

Vector database adalah penyimpanan data yang menyimpan vektor embedding, sering kali bersama teks sumber dan metadatanya, dan menjawab query nearest-neighbour: untuk sebuah vektor query, ia mengembalikan vektor tersimpan yang paling mirip, biasanya berdasarkan cosine distance, jarak Euclidean, atau inner product.

[API kompatibel OpenAI](https://broadrouter.com/id/glossary/openai-compatible-api/)

API kompatibel OpenAI adalah API HTTP yang menerima format permintaan dan respons yang sama dengan API OpenAI, seperti POST /v1/chat/completions, sehingga SDK dan tool OpenAI bisa memakainya hanya dengan mengganti base URL, kunci API, dan nama model.

## Pertanyaan umum

### Apa beda prompt caching dan response caching?

Prompt caching dilakukan oleh penyedia: prefiks prompt yang berulang ditagih dengan harga input cache yang lebih rendah, dan model tetap menulis jawaban baru. Response caching dilakukan oleh Anda: Anda menyimpan seluruh jawaban dan mengembalikannya untuk permintaan yang identik tanpa memanggil model sama sekali.

### Perlukah respons LLM di-cache pada temperature 0?

Ya, jika permintaannya tidak punya efek samping dan jawaban yang sama bisa diterima oleh semua yang mengirimnya. Temperature 0 toh tidak menjamin output identik dari serving engine, jadi cache juga membuat jawabannya konsisten. Lewati caching saat temperature di atas 0 atau tidak diisi.

### Berapa penghematan dari caching respons LLM?

Porsi permintaan yang merupakan pengulangan persis dalam jendela kedaluwarsa Anda, dikali biaya permintaan tersebut. Hitung hash permintaan yang berulang di log Anda sendiri untuk mendapatkan porsinya. Bisa mendekati nol untuk chat bebas dan tinggi untuk input FAQ atau klasifikasi yang tetap.

### Apakah semantic caching lebih baik daripada exact-match caching?

Lebih sering hit, karena pertanyaan yang mirip ikut cocok, tetapi bisa mengembalikan jawaban untuk pertanyaan yang berbeda. Semantic caching juga butuh model embedding dan vector store. Mulailah dengan exact cache, dan tambahkan lapisan semantik hanya di tempat yang hit kelirunya murah.

### Bisakah respons streaming di-cache?

Tidak dengan wrapper sederhana di sini. Anda harus mengumpulkan seluruh stream, memastikan selesai dengan normal, menyimpannya, lalu memutarnya ulang sebagai stream nanti. Kebanyakan tim hanya meng-cache panggilan non-streaming seperti klasifikasi, ekstraksi, dan jawaban FAQ.

## Baca juga

-   [Token input cache: cara memangkas tagihan API LLM](https://broadrouter.com/id/blog/cached-input-tokens-explained/)
-   [Cara menyusun prompt agar prefiksnya ter-cache](https://broadrouter.com/id/blog/prompt-structure-for-caching/)
-   [Kontrol biaya API LLM: anggaran, batas kunci, dan proteksi loop](https://broadrouter.com/id/blog/llm-api-spend-control/)
-   [Mengurangi token prompt: hasil terukur untuk system prompt, tool, data](https://broadrouter.com/id/blog/reduce-prompt-tokens/)
-   [Logging pemakaian API LLM: biaya per pengguna dan fitur, tanpa PII](https://broadrouter.com/id/blog/llm-api-usage-logging/)
-   [Batch processing LLM tanpa Batch API: runner yang bisa dilanjutkan](https://broadrouter.com/id/blog/llm-batch-processing-without-batch-api/)
-   [Hardware GPU dan pendekatan serving BroadNet, menurut BroadNet](https://broadrouter.com/id/blog/broadnet-gpu-fleet-and-serving/)
-   [Jadikan review manusia bagian dari workflow AI dokumen Anda](https://broadrouter.com/id/blog/document-review-queues/)
-   [Panduan: Memakai OpenAI Python SDK dengan BroadNet Inference](https://broadrouter.com/id/guides/openai-python-sdk/)
-   [Panduan: Kenapa model reasoning mengembalikan jawaban kosong](https://broadrouter.com/id/guides/reasoning-tokens-empty-response/)

Coba dengan beban kerja Anda yang sebenarnya. Akun baru mendapat kredit US$5 untuk Gemma dan transkripsi. DeepSeek, GLM, dan Qwen3.8 memerlukan top up.

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

**Sumber**

-   [Referensi API BroadNet Inference: penalaran dihitung dalam max\_tokens, field usage untuk token penalaran dan cache, batas bayar sesuai pemakaian (dicek 2026-11-15) (bahasa Inggris)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-cache-llm-responses-cut-cost&utm_content=sources)
-   [Pernyataan privasi inferensi BroadNet: tidak ada prompt, pesan, respons, atau transkrip yang disimpan; catatan trafik dan pemakaian tanpa konten disimpan (dicek 2026-11-15) (bahasa Inggris)](https://www.broadnet.ai/inference-privacy)
-   [GPTCache di GitHub: semantic cache dengan embedding dan similarity evaluator, false positive dan false negative, mode keyword matching tanpa embedding (dicek 2026-11-15)](https://github.com/zilliztech/GPTCache)
-   [Dokumentasi vLLM, Reproducibility: "vLLM does not guarantee the reproducibility of the results by default" (Terjemahan BroadRouter: secara default vLLM tidak menjamin hasil yang dapat direproduksi) (dicek 2026-11-15)](https://docs.vllm.ai/en/latest/usage/reproducibility.html)
-   [Dokumentasi Python, modul json: sort\_keys, separators, dan ensure\_ascii di json.dumps (dicek 2026-11-15)](https://docs.python.org/3/library/json.html)
