---
title: "Cache phản hồi API LLM để giảm chi phí (Python, SQLite)"
description: "Cache khớp chính xác đã kiểm thử cho phản hồi API LLM bằng Python: key gồm gì, thứ không bao giờ cache, TTL, quyền riêng tư và cách đo tỷ lệ trúng trước khi xây."
url: https://broadrouter.com/vi/blog/cache-llm-responses-cut-cost/
lang: vi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Được dịch từ tiếng Anh với sự hỗ trợ của AI. [Đọc bản gốc tiếng Anh](https://broadrouter.com/blog/cache-llm-responses-cut-cost/) (cập nhật ngày 2026-11-15).

# Cache phản hồi API LLM để giảm chi phí: cache khớp chính xác (Python)

Đội ngũ BroadNet Inference · 8 phút đọc · Đăng ngày 2026-11-15

Băm toàn bộ request (model, messages, temperature, max\_tokens, response\_format, tools, thiết lập suy luận và phiên bản prompt) thành key, rồi lưu câu trả lời dưới key đó kèm thời hạn. Chỉ trả câu trả lời đã lưu cho request xác định, không có tác dụng phụ. Trước tiên hãy đo tần suất request giống hệt lặp lại trong log: tỷ lệ đó là mức tối đa cache khớp chính xác tiết kiệm được.

## Ý chính

-   Cache khớp chính xác tiết kiệm cả lời gọi, gồm cả token đầu ra và token suy luận, nhưng chỉ với request giống hệt từng byte. Câu hỏi diễn đạt khác đi luôn trượt.
-   Đưa mọi tham số làm thay đổi câu trả lời vào key, cộng một phiên bản prompt. Thiếu một tham số sẽ trả câu trả lời sai; thêm nhiễu như thời gian khiến mọi request đều trượt.
-   Đừng cache câu trả lời có lấy mẫu (temperature trên 0), câu trả lời dạng stream, tool call, hay câu trả lời bị cắt ở max\_tokens.
-   Hãy đo trước: băm từng request trong log mức dùng và đếm số lần lặp lại. Các con số tiết kiệm được công bố không nói gì về traffic của bạn.
-   Cache lưu prompt và câu trả lời. Nếu nhà cung cấp không lưu nội dung inference, thì giờ cache chính là nơi chứa nội dung đó, nên hãy đặt TTL và quy tắc truy cập cho nó.

**Trong trang này**

1.  Cache phản hồi có giống prompt caching không?
2.  Cache có thực sự tiết kiệm tiền cho bạn không?
3.  Cache key gồm những gì?
4.  Cache: SQLite, TTL và chính sách bỏ qua
5.  Điều gì không bao giờ nên trả từ cache?
6.  Khi nào câu trả lời đã cache nên hết hạn?
7.  Còn semantic cache thì sao?
8.  Cache có ý nghĩa gì với quyền riêng tư?
9.  Cache kết hợp với các biện pháp kiểm soát chi phí khác thế nào?
10.  BroadNet Inference phù hợp ở đâu

Mỗi request LLM giống hệt mà bạn gửi hai lần đều bị tính tiền hai lần. Cache phản hồi lưu câu trả lời ở lần đầu và trả lại nó ở lần sau, không tính token và không phải chờ. Ý tưởng thì đơn giản. Phần khó là quyết định thế nào thì hai request là “giống hệt”, request nào không bao giờ được trả từ bộ nhớ lưu, và traffic của bạn có lặp lại đủ nhiều để đáng làm hay không.

Bài này xây một cache khớp chính xác nhỏ bằng Python trên SQLite, kiểm thử với một máy chủ giả lập tương thích OpenAI, và chỉ cách đo tỷ lệ trúng từ log trước khi bạn viết dòng code nào.

## Cache phản hồi có giống prompt caching không?

Không. Chúng tiết kiệm những thứ khác nhau, và bạn có thể dùng cả hai.

|  | Prompt caching (nhà cung cấp) | Cache phản hồi (bạn) |
| --- | --- | --- |
| Thứ được tái sử dụng | Phần mở đầu lặp lại của prompt | Toàn bộ câu trả lời |
| Ai vận hành | Nhà cung cấp API | Code của bạn |
| Model vẫn chạy? | Có, viết câu trả lời mới | Không |
| Tiết kiệm được gì | Một phần chi phí đầu vào | Token đầu vào, đầu ra và suy luận, cộng độ trễ |
| Khi nào trúng | Phần đầu dùng chung, câu hỏi khác nhau | Request giống hệt nhau |

[Token đầu vào từ cache](https://broadrouter.com/vi/blog/cached-input-tokens-explained/) giải thích phía nhà cung cấp, và [cấu trúc prompt cho cache](https://broadrouter.com/vi/blog/prompt-structure-for-caching/) chỉ cách sắp xếp prompt để phần đầu được tái sử dụng. [Công cụ tính prompt caching](https://broadrouter.com/tools/prompt-caching-calculator/) tính giá cho nó. Cache phản hồi nằm phía trước tất cả những thứ đó: khi trúng, không có request nào rời khỏi máy chủ của bạn.

## Cache có thực sự tiết kiệm tiền cho bạn không?

Hãy đo trước khi xây. Tỷ lệ tiết kiệm trong nhiều bài hướng dẫn về cache đến từ traffic của người khác. Con số của bạn phụ thuộc vào một điều: cùng một request quay lại thường xuyên thế nào trong khoảng thời hạn của bạn.

Nếu bạn đã ghi log mỗi lời gọi, như trong [ghi log mức dùng API LLM](https://broadrouter.com/vi/blog/llm-api-usage-logging/), hãy thêm một trường: `request_hash`, chính là cache key mô tả bên dưới. Nó không lưu văn bản prompt, nên phù hợp với một log không chứa nội dung. Sau đó đếm số lần lặp lại:

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

Trên một log tổng hợp gồm 20 lời gọi, một request lặp năm lần, một request khác ba lần và mười hai request duy nhất, nó in ra tỷ lệ trúng tiềm năng là 30.0%. Đó là giới hạn trên: nó bỏ qua thời hạn, và giả định mọi lần lặp đều an toàn để trả từ bộ nhớ lưu.

Rồi quy tỷ lệ đó ra tiền:

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

Token đầu ra bao gồm suy luận. Tài liệu của BroadNet nói DeepSeek V4.1 Flash, GLM 5.3 và Qwen3.8 27B suy luận trước khi trả lời và phần suy luận được tính vào `max_tokens`, nên một lần trúng tiết kiệm cả những token bạn không bao giờ thấy trong câu trả lời. Hãy lấy `completion_tokens` từ `usage` đã ghi log, không phải độ dài câu trả lời.

Một ví dụ tính bằng token: 100.000 request mỗi tháng, mỗi request 1.200 token đầu vào và 150 token đầu ra, với tỷ lệ trúng 30%, tránh được 36 triệu token đầu vào và 4,5 triệu token đầu ra. Trên [DeepSeek V4.1 Flash](https://broadrouter.com/vi/models/deepseek-v4.1-flash/), chúng lần lượt được tính $0.175 và $0.52 mỗi 1M; hãy đưa số liệu của bạn vào [công cụ tính chi phí API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/). Nếu phần lớn đầu vào đó vốn đã trúng cache của nhà cung cấp, khoản tiết kiệm đầu vào tính theo giá cache thấp hơn ($0.0055 mỗi 1M trên cùng model), nên phía đầu ra thường mới là phần quan trọng.

## Cache key gồm những gì?

Mọi thứ có thể làm thay đổi câu trả lời, và không gì khác.

-   **Đưa vào:** `model`, toàn bộ danh sách `messages` (gồm cả system prompt), `temperature`, `top_p`, `max_tokens`, `seed`, `response_format`, `tools`, `tool_choice` và `reasoning_effort`.
-   **Thêm một phiên bản prompt** do bạn kiểm soát, như `faq-v3`. Tăng nó khi bạn thay đổi prompt template, dữ liệu truy xuất hay bước hậu xử lý mà phần thân request không thể hiện.
-   **Bỏ ra** mọi thứ thay đổi theo từng lời gọi mà không làm thay đổi câu trả lời: request ID, thời gian, trace header, trường `user` mà bạn chỉ gửi để theo dõi lạm dụng.

Hãy tuần tự hóa dữ liệu làm key theo cùng một cách mỗi lần. `json.dumps` của Python với `sort_keys=True` và `separators=(",", ":")` cho ra một chuỗi chuẩn bất kể thứ tự dictionary; `ensure_ascii=False` giữ tiếng Ả Rập và văn bản không phải chữ Latin ở dạng UTF-8 thay vì ký tự thoát. Băm nó bằng SHA-256.

Thiếu một trường là lỗi nguy hiểm. Nếu `max_tokens` không có trong key, một câu trả lời bị cắt ngắn dưới giới hạn nhỏ sẽ được trả cho một request cho phép câu trả lời dài.

## Cache: SQLite, TTL và chính sách bỏ qua

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

Và một lần chạy với nó:

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

Chúng tôi chạy đoạn này với OpenAI Python SDK 3.51.0 trên một máy chủ giả lập cục bộ, máy chủ này đếm số lời gọi upstream và báo 1.200 token prompt và 150 token completion cho mỗi câu trả lời (không có lời gọi API thật). Bảy request tạo ra bốn lời gọi upstream. Script in ra `hits=3 misses=3 skipped=1 saved_input=3600 saved_output=450`. Chạy lại trên cùng file cơ sở dữ liệu, cả sáu request có thể cache đều trúng (`hits=6 misses=0`): SQLite giữ cache qua các lần khởi động lại. Các key dựng từ cùng các trường theo thứ tự khác vẫn khớp nhau.

Ghi chú về code:

-   **`max_tokens=1200`** chừa chỗ cho suy luận trước câu trả lời. Với giới hạn nhỏ, một model suy luận có thể trả về câu trả lời rỗng ([vì sao](https://broadrouter.com/vi/guides/reasoning-tokens-empty-response/)). Những câu trả lời đó không được lưu, vì `finish_reason` là `length`, không phải `stop`.
-   **Khi trúng, trả về một dict.** Khi trượt cũng trả về `model_dump()`, nên bên gọi chỉ thấy một dạng. Nếu code của bạn cần đối tượng SDK, hãy bọc cả hai.
-   **Thiếu `temperature` được coi là có lấy mẫu.** Khi đó máy chủ áp giá trị mặc định của nó, có thể lớn hơn 0, nên wrapper bỏ qua cache trừ khi bạn đặt rõ là 0.
-   **SQLite phù hợp với một hoặc vài process.** Với nhiều máy chủ, hãy đặt cùng logic key và TTL vào Redis hoặc cơ sở dữ liệu của bạn.

## Điều gì không bao giờ nên trả từ cache?

-   **Câu trả lời có lấy mẫu (temperature trên 0).** Bạn đã chọn sự đa dạng. Cache xóa bỏ điều đó, và người dùng nhấn “tạo lại” sẽ nhận đúng văn bản cũ.
-   **Câu trả lời cá nhân hóa**, trừ khi user ID có trong key. Hai người dùng cùng gửi “tóm tắt tài khoản của tôi” có hai tài khoản khác nhau. Tốt hơn: chỉ cache các request mà message không chứa dữ liệu riêng của người dùng.
-   **Tool call.** Một [tool call](https://broadrouter.com/vi/glossary/tool-calling/) là lệnh hành động. Phát lại “hoàn tiền đơn hàng 1182” từ bộ nhớ lưu có thể lặp lại một tác dụng phụ, và bước tiếp theo đúng phụ thuộc vào trạng thái hiện tại. Wrapper từ chối lưu mọi câu trả lời có `tool_calls`.
-   **Câu trả lời dạng stream.** Wrapper bỏ qua cache khi `stream=True`. Cache một stream nghĩa là phải đệm nó, kiểm tra nó đã kết thúc, rồi phát lại, điều hiếm khi đáng làm với giao diện chat.
-   **Câu trả lời bị cắt hoặc thất bại.** Chỉ lưu khi `finish_reason == "stop"`. Một câu trả lời bị cắt hay một lỗi được cache suốt một tuần là một bug trông giống lỗi của model.
-   **Câu trả lời phụ thuộc thời gian.** “Tỷ giá hôm nay là bao nhiêu?” cần TTL ngắn hoặc không cache.

Những thứ cache tốt: phân loại một tập đầu vào cố định, trích xuất từ tài liệu bạn xử lý lại, câu trả lời FAQ từ một prompt cố định, bộ kiểm thử và bộ đánh giá bạn chạy lại, và các vòng lặp phát triển nơi bạn gửi đi gửi lại cùng một request.

## Khi nào câu trả lời đã cache nên hết hạn?

Dùng ba kiểu vô hiệu hóa:

1.  **TTL.** Giới hạn thời gian cho từng mục: vài ngày cho câu trả lời FAQ ổn định, vài phút cho mọi thứ đọc dữ liệu thời gian thực.
2.  **Phiên bản trong key.** Đổi phiên bản prompt khi system prompt, chỉ mục truy xuất hay schema đầu ra thay đổi. Các mục cũ sẽ không còn khớp và tự hết hạn.
3.  **Model trong key.** Nó vốn đã có, nên chuyển từ model này sang model khác sẽ bắt đầu một cache mới, đúng điều bạn muốn khi đang [đánh giá việc chuyển đổi](https://broadrouter.com/vi/blog/evaluate-llm-before-switching/).

Hãy xóa các dòng hết hạn theo lịch (`DELETE FROM cache WHERE created < ?`). Nếu không, file chỉ lớn thêm.

Còn một lợi ích phụ. Serving engine không hứa đầu ra giống hệt cho đầu vào giống hệt: tài liệu của vLLM nói nó “does not guarantee the reproducibility of the results by default” (bản dịch: mặc định không bảo đảm khả năng tái lập kết quả). Cache cho mọi người dùng cùng một câu trả lời cho cùng một câu hỏi trong suốt thời gian sống của mục đó.

## Còn semantic cache thì sao?

Semantic cache tạo embedding cho mỗi câu hỏi và trả một câu trả lời đã lưu khi câu hỏi mới đủ gần, nên “hoàn tiền mất bao lâu?” có thể trúng “thời gian hoàn tiền là bao lâu?”. GPTCache là ví dụ mã nguồn mở nổi tiếng nhất. README của nó nói nó dùng vector store để tìm kiếm tương đồng và một bộ đánh giá độ tương đồng để quyết định trúng hay không, cảnh báo rằng “you may encounter false positives during cache hits and false negatives during cache misses” (bản dịch: bạn có thể gặp dương tính giả khi trúng cache và âm tính giả khi trượt cache), và lưu ý rằng tắt embeddings sẽ biến nó thành một cache khớp từ khóa.

Hai điểm thực tế. Thứ nhất, nó cần một model [embeddings](https://broadrouter.com/vi/glossary/embeddings/) và một vector store. BroadNet Inference không cung cấp embeddings, nên bạn sẽ dùng nhà cung cấp khác hoặc một model cục bộ cho lớp đó; [công cụ tính chi phí embedding](https://broadrouter.com/tools/embedding-cost-calculator/) tính giá các lựa chọn. Thứ hai, một lần trúng sai sẽ trả về một câu trả lời đầy tự tin cho một câu hỏi khác. Hãy dùng ngưỡng tương đồng chặt, kiểm thử nó trên các cặp câu hỏi gần giống nhưng khác nghĩa có thật, và chỉ dùng semantic cache cho các câu trả lời ít rủi ro. Dù thế nào cũng hãy đặt cache khớp chính xác ở phía trước: kiểm tra nó không tốn gì và nó không bao giờ sai về việc người dùng đã hỏi gì.

## Cache có ý nghĩa gì với quyền riêng tư?

Cache là một kho lưu prompt và câu trả lời. Điều đó thay đổi nơi dữ liệu của bạn nằm.

[Tuyên bố quyền riêng tư inference](https://www.broadnet.ai/inference-privacy) của BroadNet, kiểm tra ngày 2026-11-15, nói gateway của họ không giữ prompt, message, phản hồi hay bản chép lời, trong khi các bản ghi traffic và mức dùng không chứa nội dung (số token, chi phí, thời gian) thì được giữ. Nội dung inference không được lưu giữ. Metadata cần thiết về tài khoản, thanh toán và bảo mật được giữ như tuyên bố đó mô tả. Khi bạn thêm cache phản hồi, hệ thống của bạn giữ nội dung mà nhà cung cấp không giữ. Hãy đối xử với nó như mọi kho dữ liệu người dùng khác:

-   Ở chỗ nào có thể, chỉ cache các request không có dữ liệu cá nhân, việc này còn giúp tăng tỷ lệ trúng.
-   Đặt TTL đủ ngắn theo chính sách lưu giữ của bạn, và xóa theo lịch.
-   Mã hóa file hoặc bảng khi lưu trữ và giới hạn ai được đọc.
-   Đưa cache vào phạm vi các yêu cầu xóa dữ liệu nếu nó có thể chứa văn bản của người dùng.

[Gửi dữ liệu nhạy cảm tới API LLM](https://broadrouter.com/vi/blog/llm-api-sensitive-data/) đề cập phần còn lại của checklist đó.

## Cache kết hợp với các biện pháp kiểm soát chi phí khác thế nào?

Cache loại bỏ các lời gọi lặp lại. Nó không làm gì với các lời gọi duy nhất, nên nó đứng cạnh các biện pháp khác chứ không thay thế chúng: [prompt ngắn hơn](https://broadrouter.com/vi/blog/reduce-prompt-tokens/), prompt caching của nhà cung cấp, trần `max_tokens` cho mỗi request, cùng ngân sách và giới hạn vòng lặp từ [kiểm soát chi phí API LLM](https://broadrouter.com/vi/blog/llm-api-spend-control/). Với các tác vụ lớn chạy một lần, hãy loại trùng đầu vào trước khi gửi; đó cũng là ý tưởng của cache, chỉ làm một lần. [Xử lý tác vụ lớn mà không cần Batch API](https://broadrouter.com/vi/blog/llm-batch-processing-without-batch-api/) trình bày phía tác vụ.

Trên gói giá cố định, phép tính thay đổi. Các phiên DeepSeek của BroadNet không đếm token, nên một lần trúng cache không tiết kiệm được tiền ở đó. Nó vẫn tiết kiệm thời gian: một phiên chạy một request tại một thời điểm, nên mỗi lần lặp bạn bỏ qua sẽ giải phóng phiên cho công việc mới.

## BroadNet Inference phù hợp ở đâu

BroadRouter là trang của chính BroadNet. BroadNet Inference cung cấp DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B và Gemma 4 VL 26B qua một endpoint `/v1/chat/completions` tương thích OpenAI, nên wrapper ở trên chạy được với [OpenAI Python SDK](https://broadrouter.com/vi/guides/openai-python-sdk/) chỉ bằng cách đổi base URL. Nó không có tính năng cache phản hồi riêng; cache trong bài này là của bạn. Các lần trúng cache phía nhà cung cấp được báo cáo trong `usage.prompt_tokens_details.cached_tokens` và tính theo giá đầu vào từ cache, theo [tài liệu tham chiếu API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=vi-blog-cache-llm-responses-cut-cost&utm_content=body). Giá theo từng model có trên [trang giá](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=vi-blog-cache-llm-responses-cut-cost&utm_content=body).

Công cụ miễn phí cho chủ đề này (tiếng Anh)

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

[Công cụ miễn phí (tiếng Anh)](https://broadrouter.com/tools/)

## Thuật ngữ trong bài này

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

Token là đơn vị văn bản mà model ngôn ngữ đọc và viết: một từ, một phần của từ, một dấu câu hoặc một chuỗi byte do tokenizer của model tạo ra. API LLM đếm, giới hạn và thường tính phí theo token.

[Embedding (vector nhúng)](https://broadrouter.com/vi/glossary/embeddings/)

Embedding là danh sách số thực (vector) mà một model tạo ra để biểu diễn đoạn văn bản, hình ảnh hay đầu vào khác. Đầu vào có nghĩa tương tự nhận vector gần nhau, nên khoảng cách giữa vector dùng được để xếp hạng kết quả tìm kiếm, gom cụm tài liệu hoặc tìm mục liên quan.

[Token đầu vào từ cache (cached input tokens)](https://broadrouter.com/vi/glossary/cached-input-tokens/)

Token đầu vào từ cache là token prompt mà nhà cung cấp LLM vừa xử lý gần đây và có thể dùng lại từ cache thay vì tính toán lại, thường là phần đầu lặp lại như system prompt hoặc tài liệu. Nhà cung cấp tính giá chúng thấp hơn token đầu vào mới.

[Token đầu vào và đầu ra (input and output tokens)](https://broadrouter.com/vi/glossary/input-and-output-tokens/)

Token đầu vào là token mà model ngôn ngữ đọc trong một request, gồm system prompt, lịch sử hội thoại, định nghĩa tool và hình ảnh. Token đầu ra là token nó sinh ra để trả lời, kể cả phần suy luận. API LLM thường tính giá riêng cho hai loại, và đầu ra thường đắt hơn.

[Tool calling (gọi tool, function calling)](https://broadrouter.com/vi/glossary/tool-calling/)

Tool calling, còn gọi là function calling, là tính năng của API LLM trong đó model trả về một yêu cầu có cấu trúc để chạy một hàm do nhà phát triển định nghĩa, kèm đối số JSON. Ứng dụng chạy hàm rồi gửi kết quả lại; model không bao giờ tự chạy code.

[Vector database (cơ sở dữ liệu vector)](https://broadrouter.com/vi/glossary/vector-database/)

Vector database (cơ sở dữ liệu vector) là kho dữ liệu lưu các vector embedding, thường kèm văn bản gốc và metadata, và trả lời truy vấn láng giềng gần nhất: với một vector truy vấn, nó trả về các vector đã lưu giống nhất, thường đo bằng khoảng cách cosine, khoảng cách Euclid hoặc tích vô hướng.

[API tương thích OpenAI (OpenAI-compatible API)](https://broadrouter.com/vi/glossary/openai-compatible-api/)

API tương thích OpenAI là một HTTP API nhận cùng định dạng request và phản hồi như OpenAI API, ví dụ POST /v1/chat/completions, nên SDK và công cụ của OpenAI dùng được nó chỉ bằng cách đổi base URL, API key và tên model.

[System prompt (lời nhắc hệ thống)](https://broadrouter.com/vi/glossary/system-prompt/)

System prompt là đoạn chỉ dẫn mà ứng dụng gửi cho model ngôn ngữ trước cuộc hội thoại, thường là tin nhắn có vai trò system hoặc developer. Nó đặt vai trò, quy tắc, giọng điệu và định dạng đầu ra, và model được kỳ vọng tuân theo nó hơn các tin nhắn người dùng mâu thuẫn.

## Câu hỏi thường gặp

### Prompt caching và cache phản hồi khác nhau thế nào?

Prompt caching do nhà cung cấp thực hiện: phần đầu prompt lặp lại được tính theo giá đầu vào từ cache thấp hơn, và model vẫn viết câu trả lời mới. Cache phản hồi do bạn thực hiện: bạn lưu toàn bộ câu trả lời và trả lại nó cho một request giống hệt mà không gọi model chút nào.

### Có nên cache phản hồi LLM ở temperature 0 không?

Có, nếu request không có tác dụng phụ và cùng một câu trả lời chấp nhận được với mọi người gửi nó. Dù sao temperature 0 cũng không bảo đảm đầu ra giống hệt từ serving engine, nên cache còn giúp câu trả lời nhất quán. Đừng cache khi temperature trên 0 hoặc bị bỏ trống.

### Cache phản hồi LLM tiết kiệm được bao nhiêu?

Bằng tỷ lệ request lặp lại chính xác trong khoảng thời hạn của bạn, nhân với chi phí của các request đó. Đếm các hash request lặp lại trong log của chính bạn để có tỷ lệ đó. Nó có thể gần bằng không với chat mở và cao với đầu vào FAQ hay phân loại cố định.

### Semantic cache có tốt hơn cache khớp chính xác không?

Nó trúng thường xuyên hơn, vì các câu hỏi tương tự cũng khớp, nhưng nó có thể trả câu trả lời cho một câu hỏi khác. Nó cũng cần một model embeddings và một vector store. Hãy bắt đầu bằng cache khớp chính xác, và chỉ thêm lớp semantic ở nơi một lần trúng sai không gây hại nhiều.

### Có cache được phản hồi dạng stream không?

Không với wrapper đơn giản ở đây. Bạn sẽ phải gom toàn bộ stream, kiểm tra nó kết thúc bình thường, lưu lại, và phát lại dưới dạng stream sau đó. Phần lớn đội ngũ chỉ cache các lời gọi không stream như phân loại, trích xuất và câu trả lời FAQ.

## Đọc tiếp

-   [Token đầu vào từ cache: cách giảm hóa đơn API LLM](https://broadrouter.com/vi/blog/cached-input-tokens-explained/)
-   [Cách cấu trúc prompt để phần đầu được cache](https://broadrouter.com/vi/blog/prompt-structure-for-caching/)
-   [Kiểm soát chi phí API LLM: ngân sách, giới hạn key và chặn vòng lặp](https://broadrouter.com/vi/blog/llm-api-spend-control/)
-   [Giảm token prompt: số đo thực cho system prompt, tool và dữ liệu](https://broadrouter.com/vi/blog/reduce-prompt-tokens/)
-   [Ghi log sử dụng API LLM: chi phí theo người dùng, tính năng, ẩn PII](https://broadrouter.com/vi/blog/llm-api-usage-logging/)
-   [Xử lý LLM hàng loạt không cần Batch API: runner chạy tiếp được](https://broadrouter.com/vi/blog/llm-batch-processing-without-batch-api/)
-   [Phần cứng GPU và cách phục vụ model của BroadNet, theo lời BroadNet](https://broadrouter.com/vi/blog/broadnet-gpu-fleet-and-serving/)
-   [Đưa bước người duyệt vào quy trình AI xử lý tài liệu](https://broadrouter.com/vi/blog/document-review-queues/)
-   [Hướng dẫn: Dùng OpenAI Python SDK với BroadNet Inference](https://broadrouter.com/vi/guides/openai-python-sdk/)
-   [Hướng dẫn: Vì sao model suy luận trả về câu trả lời rỗng](https://broadrouter.com/vi/guides/reasoning-tokens-empty-response/)

Hãy thử với khối lượng công việc thực tế của bạn. Tài khoản mới được tặng US$5 tín dụng ban đầu cho Gemma và chuyển giọng nói thành văn bản. DeepSeek, GLM và Qwen3.8 cần nạp tiền.

[Bắt đầu](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=vi-blog-cache-llm-responses-cut-cost&utm_content=page-cta) ·

**Nguồn**

-   [Tài liệu tham chiếu API BroadNet Inference: suy luận tính vào max\_tokens, các trường usage cho token suy luận và token từ cache, giới hạn trả theo mức dùng (kiểm tra ngày 2026-11-15) (tiếng Anh)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=vi-blog-cache-llm-responses-cut-cost&utm_content=sources)
-   [Tuyên bố quyền riêng tư inference của BroadNet: không giữ prompt, message, phản hồi hay bản chép lời; giữ bản ghi traffic và mức dùng không chứa nội dung (kiểm tra ngày 2026-11-15) (tiếng Anh)](https://www.broadnet.ai/inference-privacy)
-   [GPTCache trên GitHub: semantic cache dùng embeddings và bộ đánh giá độ tương đồng, dương tính giả và âm tính giả, chế độ khớp từ khóa không cần embeddings (kiểm tra ngày 2026-11-15)](https://github.com/zilliztech/GPTCache)
-   [Tài liệu vLLM, Reproducibility: “vLLM does not guarantee the reproducibility of the results by default” (bản dịch: vLLM mặc định không bảo đảm khả năng tái lập kết quả) (kiểm tra ngày 2026-11-15)](https://docs.vllm.ai/en/latest/usage/reproducibility.html)
-   [Tài liệu Python, module json: sort\_keys, separators và ensure\_ascii trong json.dumps (kiểm tra ngày 2026-11-15)](https://docs.python.org/3/library/json.html)
