Hướng dẫn LMCache: Xây dựng lớp bộ nhớ đệm KV có khả năng mở rộng cho suy luận LLM

Suy luận mô hình ngôn ngữ lớn có thể ngày càng tốn kém khi prompt phình to. 

Hệ thống RAG, tác nhân lập trình, quy trình đa tác nhân và đối thoại dài thường gửi lặp lại cùng tài liệu, system prompt, định nghĩa công cụ hoặc lịch sử hội thoại cho mô hình.

Mỗi lần ngữ cảnh dùng chung này được xử lý trong giai đoạn prefill, mô hình tạo ra các trạng thái key-value (KV) được sử dụng trong quá trình sinh token. 

Tính toán lại các trạng thái đó cho cùng một ngữ cảnh làm lãng phí tài nguyên GPU và tăng độ trễ.

LMCache giải quyết vấn đề này bằng cách bổ sung một lớp bộ nhớ đệm KV chuyên dụng vào ngăn xếp suy luận. 

Nó có thể lưu trữ các trạng thái KV đã tính và tái sử dụng chúng giữa các yêu cầu và worker suy luận, đồng thời hỗ trợ CPU, lưu trữ cục bộ, backend từ xa và kiến trúc phục vụ tách rời.

Trong hướng dẫn này, tôi sẽ giới thiệu cách LMCache hoạt động, khác gì so với bộ nhớ đệm KV gốc của vLLM, và các tính năng như lưu trữ đa tầng, bộ đệm dùng chung, CacheBlend, cùng tách rời prefill/decode nằm ở đâu trong phục vụ LLM hiện đại. 

Sau đó bạn sẽ kết nối LMCache với vLLM, phục vụ IBM Granite 4.2 3B, và chạy thí nghiệm có kiểm soát để đo lường tác động của việc tái sử dụng một tiền tố dùng chung lớn lên độ trễ suy luận.

LMCache là gì?

LMCache là một lớp quản lý bộ nhớ đệm KV cho suy luận LLM mã nguồn mở. 

Nó cho phép lưu trữ các trạng thái key-value tạo ra trong prefill và tái sử dụng khi các yêu cầu sau chia sẻ cùng tiền tố prompt.

Nguồn: LMCache – Xây dựng nền tảng bộ nhớ tensor cho AI với hạ tầng KV Cache 

Điều này khác với bộ nhớ đệm phản hồi truyền thống. 

Bộ nhớ đệm phản hồi lưu câu trả lời đã sinh cuối cùng và trả lại khi gặp lại cùng yêu cầu:

cache = {
    "What is Python?":
        "Python is a general-purpose programming language..."
}Được hỗ trợ bởi

LMCache hoạt động sớm hơn trong quá trình suy luận. Thay vì đệm phản hồi cuối, nó lưu các trạng thái chú ý KV tạo ra khi mô hình xử lý prompt.

Ví dụ, nếu không có bộ nhớ đệm KV tái sử dụng, một prompt dùng chung dài phải chạy lại prefill mỗi khi thêm câu hỏi mới. 

Với LMCache, yêu cầu đầu tiên thực hiện toàn bộ prefill và lưu các trạng thái KV thu được. Các yêu cầu sau đó có cùng tiền tố có thể tải lại các trạng thái đó và chỉ xử lý các token mới.

Hình 1: Không có bộ đệm KV tái sử dụng, toàn bộ prompt bị tính lại cho mọi yêu cầu; với LMCache, các trạng thái KV được tái sử dụng và chỉ token mới được xử lý.

Điều này càng có giá trị khi cửa sổ ngữ cảnh tăng lên. 

Xử lý lại vài trăm token có thể rẻ, nhưng lặp lại xử lý hàng chục nghìn token dùng chung có thể làm tăng đáng kể độ trễ và mức sử dụng GPU.

Cách LMCache hoạt động

Cách dễ nhất để hiểu LMCache là theo dõi hai yêu cầu có cùng tiền tố.

Với yêu cầu đầu tiên, LMCache kiểm tra xem đã có trạng thái KV tái sử dụng chưa. Vì đây là lần đầu prompt xuất hiện, tra cứu sẽ bị trượt bộ đệm.

vLLM sau đó thực hiện prefill trên GPU, tạo trạng thái KV và chuyển cho LMCache để lưu trữ.

Với yêu cầu thứ hai, tiền tố dùng chung giữ nguyên, nhưng câu hỏi thay đổi.

LMCache lại tra cứu. Lần này, tiền tố đã có sẵn, dẫn đến trúng bộ đệm. Các trạng thái đã đệm được tái sử dụng và GPU chỉ cần xử lý phần hậu tố chưa đệm.

Hình 2: Yêu cầu đầu với tiền tố mới trượt bộ đệm, nên vLLM tính prefill và lưu trạng thái KV vào LMCache; yêu cầu lặp lại với cùng tiền tố trúng bộ đệm và chỉ tính phần hậu tố mới.

Điểm quan trọng là LMCache không yêu cầu toàn bộ yêu cầu phải giống hệt nhau. Điều quan trọng là tiền tố có thể tái sử dụng.

Điều đó khiến nó phù hợp với các ứng dụng mà bối cảnh nền giữ nguyên trong khi truy vấn của người dùng thay đổi.

Bộ đệm tiền tố của vLLM so với LMCache

vLLM đã hỗ trợ bộ đệm tiền tố tự động, nên hợp lý khi hỏi vì sao còn cần LMCache.

Cả hai cách đều cố tránh tính lại trạng thái KV cho tiền tố prompt mà mô hình đã xử lý. 

Khác biệt chính là bộ đệm nằm ở đâu và mức độ tái sử dụng rộng đến đâu.

Bộ đệm tiền tố tích hợp của vLLM là lựa chọn đơn giản hơn khi các yêu cầu lặp lại được xử lý bởi cùng máy chủ suy luận. 

Nếu nhiều yêu cầu bắt đầu bằng cùng token, vLLM có thể tái sử dụng các khối KV sẵn có thay vì thực hiện lại toàn bộ prefill.

LMCache mở rộng ý tưởng này vượt ra ngoài động cơ suy luận.

Thay vì chỉ giữ trạng thái KV tái sử dụng trong bộ đệm riêng của vLLM, LMCache giới thiệu một lớp bộ đệm riêng có thể lưu trữ và di chuyển trạng thái KV qua các tầng lưu trữ bổ sung và cung cấp cho kiến trúc phục vụ rộng hơn.

Cách hình dung đơn giản về sự khác biệt là:

Hình 3: Bộ đệm tiền tố vLLM so với LMCache. LMCache thêm một lớp bộ đệm phân tầng trạng thái KV qua bộ nhớ CPU, SSD/NVMe cục bộ và lưu trữ từ xa thay vì chỉ bộ nhớ GPU.

Vì vậy LMCache không thay thế ý tưởng bộ đệm KV trong vLLM. Nó mở rộng quản lý KV-cache vượt khỏi ranh giới thông thường của động cơ suy luận.

Các tính năng chính của LMCache

LMCache không chỉ là bộ đệm trong bộ nhớ đơn giản. Nó được thiết kế để lưu trữ, di chuyển và tái sử dụng trạng thái KV qua các tầng lưu trữ và worker suy luận khác nhau.

1. Tái sử dụng bộ đệm KV

Tính năng chính của LMCache là khả năng tái sử dụng trạng thái KV đã tính thay vì cho mô hình xử lý lại cùng token.

Điều này đặc biệt hữu ích khi yêu cầu lặp lại cùng hoặc tương tự ngữ cảnh, như:

• Tài liệu được truy xuất
• System prompt lớn
• Ngữ cảnh kho mã
• Lịch sử hội thoại
• Định nghĩa công cụ
• Chỉ dẫn dùng chung giữa các tác nhân

Bằng cách tái sử dụng trạng thái KV đã đệm, LMCache có thể giảm tính toán prefill lặp lại và cải thiện thời gian đến token đầu tiên.

2. Lưu trữ đa tầng

Bộ nhớ GPU có hạn và đắt đỏ, nhất là với ngữ cảnh dài.

LMCache có thể di chuyển trạng thái KV vượt khỏi bộ nhớ GPU và lưu trữ qua nhiều tầng, gồm bộ nhớ CPU, SSD hoặc NVMe cục bộ, và lưu trữ từ xa hoặc phân tán.

Điều này giúp giữ được nhiều ngữ cảnh có thể tái sử dụng hơn mức có thể nhét vừa hoàn toàn trong bộ nhớ GPU, đồng thời vẫn đưa lại các trạng thái KV dùng thường xuyên lên GPU khi cần.

3. Bộ đệm KV dùng chung giữa các worker

LMCache có thể cho phép nhiều worker suy luận dùng được các trạng thái KV đã đệm thay vì gắn chặt chúng với một tiến trình mô hình.

Ví dụ, nếu một worker vLLM xử lý tài liệu dài, worker khác có thể tái sử dụng trạng thái KV đã đệm thay vì tính lại cùng ngữ cảnh.

Điều này đặc biệt hữu ích cho phục vụ phân tán, triển khai đa GPU và các ứng dụng điều phối yêu cầu qua nhiều bản sao suy luận.

4. Tích hợp vLLM

LMCache tích hợp với vLLM qua giao diện trình kết nối KV.

Ứng dụng có thể tiếp tục giao tiếp với endpoint vLLM tương thích OpenAI như bình thường trong khi LMCache vận hành bên dưới lớp suy luận.

Điều này nghĩa là ứng dụng hiện có không cần thay đổi cách gửi prompt hay nhận phản hồi. LMCache xử lý lưu trữ và truy xuất KV giữa vLLM và backend bộ đệm đã cấu hình.

5. Kiến trúc đa tiến trình

LMCache có thể chạy như một tiến trình tách biệt khỏi vLLM.

Thay vì giữ quản lý bộ đệm trong mỗi worker suy luận, một máy chủ LMCache chuyên dụng có thể quản lý trạng thái KV độc lập và phục vụ nhiều tiến trình vLLM.

Điều này tách quản lý bộ đệm khỏi phục vụ mô hình, cho phép nhiều worker dùng chung bộ đệm và dễ dàng mở rộng dung lượng bộ đệm độc lập với tài nguyên suy luận GPU.

6. CacheBlend

Bộ đệm tiền tố truyền thống hoạt động tốt nhất khi các yêu cầu chia sẻ phần đầu prompt. 

LMCache cũng cung cấp CacheBlend cho khối lượng công việc mà nội dung có thể tái sử dụng xuất hiện ở các vị trí khác nhau.

Ví dụ, một ứng dụng RAG có thể truy xuất cùng tài liệu theo thứ tự khác nhau cho các câu hỏi khác nhau. 

CacheBlend có thể tái sử dụng các phần trạng thái KV đã tính trước đồng thời chọn lọc tính lại các token phụ thuộc vào ngữ cảnh mới.

Điều này giúp tái sử dụng KV hữu ích hơn cho RAG, ứng dụng đa tài liệu và quy trình tác nhân nơi prompt thường xuyên được sắp xếp lại.

7. Tách rời prefill và decode

LMCache cũng có thể hỗ trợ truyền trạng thái KV giữa các worker prefill và decode tách biệt.

Trong kiến trúc này, một nhóm GPU xử lý giai đoạn xử lý prompt nặng tính toán, trong khi nhóm khác xử lý sinh token. 

LMCache cung cấp lớp dùng để di chuyển trạng thái KV thu được giữa chúng.

Điều này cho phép mở rộng tài nguyên prefill và decode độc lập và có thể cải thiện mức sử dụng GPU trong triển khai suy luận lớn.

Bắt đầu với LMCache 

Giờ khi đã hiểu LMCache hoạt động ra sao, hãy kết nối nó với vLLM, một động cơ suy luận LLM hiệu năng cao được thiết kế cho phục vụ hiệu quả và quản lý bộ nhớ.

Trong hướng dẫn này, tôi sẽ dùng IBM Granite 4.2 3B, một mô hình gọn nhẹ cho hiệu năng tốt so với kích thước và đủ nhẹ cho thử nghiệm thực tế.

Chúng ta sẽ chạy LMCache ở chế độ đa tiến trình cùng với vLLM và xác minh rằng trạng thái KV có thể tái sử dụng giữa các yêu cầu.

1. Thiết lập môi trường

Trong hướng dẫn này, chúng ta sẽ dùng Python 3.12, uv, vLLM, LMCache, OpenAI Python client, pandas và matplotlib.

Trước khi bắt đầu, hãy đảm bảo bạn có:

• GPU NVIDIA với driver phù hợp đã cài đặt
• Bộ công cụ CUDA 13 đã cài và sẵn sàng trên hệ thống
• uv đã cài đặt

Bạn có thể cài uv bằng:

curl -LsSf https://astral.sh/uv/install.sh | shĐược hỗ trợ bởi

Sau đó tạo project:

mkdir lmcache-tutorial
cd lmcache-tutorialĐược hỗ trợ bởi

Tạo và kích hoạt môi trường ảo Python 3.12:

uv venv --python 3.12
source .venv/bin/activateĐược hỗ trợ bởi

Cài các phụ thuộc cần thiết:

uv pip install -U \
    "lmcache==0.5.4" \
    "vllm==0.28.0" \
    openai \
    pandas \
    matplotlib \
    --torch-backend=cu130Được hỗ trợ bởi

Ở đây, chúng ta dùng cu130 vì môi trường được thiết lập với CUDA 13. 

Nếu bạn dùng phiên bản CUDA khác, hãy đổi giá trị --torch-backend sang backend PyTorch tương thích với môi trường của bạn.

Granite 4.2 dùng trình phân tích suy luận tuỳ chỉnh, nên hãy tải từ Hugging Face:

hf download ibm-granite/granite-4.2-3b \
    granite_thinking_parser.py \
    --local-dir .Được hỗ trợ bởi

Cuối cùng, kiểm tra GPU và cài đặt CUDA của bạn được nhận diện:

nvidia-smiĐược hỗ trợ bởi

Trong hướng dẫn này, chúng tôi dùng NVIDIA GeForce RTX 5070 Ti với 16 GB VRAM. 

Hệ thống chạy driver NVIDIA 580.126.09, hỗ trợ CUDA 13.0. 

2. Khởi động vLLM với LMCache 

Chúng ta cần hai tiến trình đang chạy: một cho máy chủ LMCache và một cho vLLM.

Khởi động LMCache ở terminal thứ nhất:

lmcache server \
    --host localhost \
    --port 6555 \
    --http-port 8081 \
    --l1-size-gb 20 \
    --eviction-policy LRUĐược hỗ trợ bởi

Ở đây, chúng ta dùng:

• cổng 6555 cho giao tiếp giữa vLLM và LMCache
• cổng 8081 cho giao diện HTTP của LMCache
• 20 GB cho bộ đệm L1
• LRU làm chính sách loại bỏ

Giữ terminal này chạy.

Mở terminal thứ hai, kích hoạt cùng môi trường ảo, và huỷ đặt cấu hình bộ cấp phát CUDA mở rộng nếu đang bật:

cd lmcache-tutorial
source .venv/bin/activate
unset PYTORCH_CUDA_ALLOC_CONFĐược hỗ trợ bởi

Giờ khởi động vLLM với trình kết nối LMCache: 

vllm serve ibm-granite/granite-4.2-3b \
  --served-model-name granite-4.2-3b \
  --dtype bfloat16 \
  --max-model-len 65536 \
  --kv-cache-dtype fp8 \
  --gpu-memory-utilization 0.90 \
  --enforce-eager \
  --max-num-seqs 1 \
  --max-num-batched-tokens 2048 \
  --no-enable-prefix-caching \
  --reasoning-parser granite_thinking_parser \
  --reasoning-parser-plugin "$(pwd)/granite_thinking_parser.py" \
  --tool-call-parser qwen3_coder \
  --enable-auto-tool-choice \
  --port 8000 \
  --kv-transfer-config \
  '{
    "kv_connector":"LMCacheMPConnector",
    "kv_connector_module_path":"lmcache.integration.vllm.lmcache_mp_connector",
    "kv_role":"kv_both",
    "kv_connector_extra_config":{
      "lmcache.mp.host":"tcp://localhost",
      "lmcache.mp.port":6555,
      "lmcache.mp.mp_transfer_mode":"lmcache_driven"
    }
  }'Được hỗ trợ bởi

Chúng ta tắt bộ đệm tiền tố tích hợp của vLLM bằng:

--no-enable-prefix-cachingĐược hỗ trợ bởi

Điều này cho phép các thí nghiệm sau tập trung cụ thể vào tái sử dụng KV qua LMCache.

Khi vLLM tải xong, mô hình khả dụng qua endpoint tương thích OpenAI của nó:

http://localhost:8000/v1Được hỗ trợ bởi

3. Xác minh LMCache với một lần trúng bộ đệm có kiểm soát

Giờ chúng ta sẽ thực hiện một thí nghiệm đơn giản có kiểm soát để xác nhận LMCache đang hoạt động.

Chúng ta sẽ tạo một tiền tố dùng chung lớn, xoá bộ đệm, gửi tiền tố một lần để làm nóng LMCache, rồi gửi yêu cầu khác với cùng tiền tố nhưng câu hỏi khác.

Đầu tiên, tạo OpenAI client:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="local",
)Được hỗ trợ bởi

Tiếp theo, tạo tài liệu dùng chung dài:

base_text = """
Large language model inference consists of two main stages:
prefill and decoding.

During prefill, the model processes the input sequence and calculates
the key and value tensors used by the attention mechanism.

During autoregressive decoding, these tensors are reused so the model
does not need to recompute attention states for every previous token.

KV cache management is therefore an important part of modern LLM
serving infrastructure, particularly for long-context applications.
"""

document = base_text * 500

SYSTEM_PROMPT = f"""
You are a technical assistant.

Use only the following document to answer the user's question.

DOCUMENT:

{document}
"""Được hỗ trợ bởi

Lặp lại tài liệu 500 lần cho ta một tiền tố dùng chung lớn đủ đắt để thấy rõ hiệu ứng tái sử dụng KV.

Trước khi gửi yêu cầu đầu tiên, hãy xoá LMCache để bắt đầu với bộ đệm trống:

import subprocess
import time

subprocess.run(
    [
        "lmcache",
        "kvcache",
        "clear",
        "--url",
        "http://localhost:8081",
    ],
    check=True,
)

time.sleep(0.5)Được hỗ trợ bởi

Điều này đảm bảo yêu cầu đầu là yêu cầu bộ đệm lạnh và không thể tái sử dụng trạng thái KV còn sót từ thử nghiệm trước.

Giờ hãy gửi yêu cầu đầu tiên:

prompt_1 = SYSTEM_PROMPT + """

Question:
Explain the purpose of the KV cache.
"""

start = time.perf_counter()

client.completions.create(
    model="granite-4.2-3b",
    prompt=prompt_1,
    max_tokens=100,
    temperature=0,
)

latency_1 = time.perf_counter() - startĐược hỗ trợ bởi

Đây là yêu cầu làm nóng bộ đệm. vLLM phải xử lý tiền tố dùng chung dài trong prefill, trong khi LMCache lưu các trạng thái KV thu được.

Tiếp theo, giữ y nguyên tiền tố dùng chung và chỉ đổi câu hỏi:

prompt_2 = SYSTEM_PROMPT + """

Question:
Explain what happens during prefill.
"""

start = time.perf_counter()

client.completions.create(
    model="granite-4.2-3b",
    prompt=prompt_2,
    max_tokens=100,
    temperature=0,
)

latency_2 = time.perf_counter() - startĐược hỗ trợ bởi

Vì tiền tố lớn không đổi, LMCache có thể tái sử dụng các trạng thái KV tạo ra từ yêu cầu đầu thay vì tính lại toàn bộ tiền tố.

Cuối cùng, so sánh thời gian hai yêu cầu:

print(f"Cold request:   {latency_1:.3f}s")
print(f"Warm request:   {latency_2:.3f}s")
print(f"Speedup:        {latency_1 / latency_2:.2f}x")

print(
    f"Latency saved:  "
    f"{((latency_1 - latency_2) / latency_1) * 100:.1f}%"
)Được hỗ trợ bởi

Kết quả chạy của tôi:

Cold request:   26.276s
Warm request:   4.402s
Speedup:        5.97x
Latency saved:  83.2%Được hỗ trợ bởi

Yêu cầu ấm hoàn thành gần như nhanh hơn 6×, giảm độ trễ đầu-cuối 83,2%.

Các câu hỏi khác nhau, nên LMCache không đệm phản hồi cuối. Thay vào đó, nó tái sử dụng các trạng thái KV tạo cho tiền tố dùng chung.

Yêu cầu đầu phải xử lý toàn bộ tiền tố dài trong prefill và tạo trạng thái KV từ đầu. 

Ở yêu cầu thứ hai, LMCache truy xuất trạng thái đã đệm phù hợp, cho phép vLLM bỏ qua phần lớn công việc prefill lặp lại và tập trung vào hậu tố mới.

Điều này xác nhận LMCache đang tái sử dụng thành công tiền tố dùng chung. 

LMCache hữu ích khi nào?

LMCache đặc biệt hữu ích khi ứng dụng thường xuyên gửi lượng lớn ngữ cảnh giống hệt nhau.

Một vài ví dụ phổ biến:

Ứng dụng RAG

Người dùng có thể hỏi nhiều câu về cùng một tài liệu đã truy xuất.

Thay vì xử lý lại toàn bộ tài liệu cho mỗi câu hỏi, có thể tái sử dụng trạng thái KV của nó.

Tác nhân lập trình

Trợ lý lập trình thường gửi file kho mã, hướng dẫn dự án và các phần ngữ cảnh lớn trong mỗi lần gọi mô hình.

Phần lớn ngữ cảnh đó giữ nguyên trong khi nhiệm vụ thay đổi.

Tác nhân AI

Các tác nhân thường tái sử dụng system prompt lớn, định nghĩa công cụ, bộ nhớ, chỉ dẫn và trạng thái môi trường qua nhiều bước.

Cuộc hội thoại dài

Một cuộc trò chuyện kéo dài có thể lặp lại gửi một phần đáng kể lịch sử của nó với mỗi tin nhắn mới.

Hệ thống đa tác nhân

Nhiều tác nhân có thể chia sẻ cùng tài liệu nền hoặc ngữ cảnh hệ thống trong khi làm các nhiệm vụ khác nhau.

Trong tất cả các trường hợp này, mô hình liên tục được đưa xem lại thông tin mà nó đã xử lý ở các yêu cầu trước.

LMCache cung cấp cách tái sử dụng công việc đó ở cấp bộ đệm KV.

Tổng kết

LMCache giải quyết nguồn lãng phí lớn trong suy luận ngữ cảnh dài bằng cách làm cho các trạng thái KV tạo trong prefill có thể tái sử dụng. 

Thay vì xử lý đi xử lý lại cùng ngữ cảnh dùng chung, mô hình có thể tái sử dụng công việc đã hoàn thành.

Chúng tôi không đưa mã benchmark hoặc kết quả chi tiết trong hướng dẫn này, nhưng đã chạy một bộ thử nghiệm riêng với cùng thiết lập. 

Kết quả rất đáng kể. Tái sử dụng tiền tố dùng chung lớn giảm độ trễ tổng yêu cầu từ 26,276 giây xuống 4,386 giây. 

Thời gian trung bình đến token đầu tiên giảm từ 22,149 giây xuống 0,726 giây, cải thiện 30,54×. Lợi ích cũng tăng theo kích thước ngữ cảnh, từ 3,55× với khoảng 12.000 ký tự dùng chung đến 30,22× với xấp xỉ 245.000 ký tự. 

Nói đơn giản, càng tái sử dụng được nhiều ngữ cảnh, LMCache càng tránh được nhiều công việc.

DeepSeek là ví dụ thực tế tốt cho thấy điều này quan trọng thế nào.

Hệ thống bộ đệm của họ có thể tái sử dụng tiền tố prompt trùng khớp, đặc biệt hữu ích cho tác nhân lập trình thường xuyên gửi lại cùng system prompt, công cụ, lịch sử hội thoại và ngữ cảnh mã. 

Tỷ lệ trúng bộ đệm cao hơn đồng nghĩa ít tính toán lặp lại hơn và chi phí thấp hơn cho cả nhà cung cấp lẫn người dùng.

Thông điệp chính từ hướng dẫn này là suy luận LLM nhanh hơn không chỉ nhờ GPU tốt hơn hay sinh token nhanh hơn. Đó còn là về việc không lặp lại công việc không cần thiết. 

Đối với hệ thống RAG, trợ lý lập trình, tác nhân và các ứng dụng ngữ cảnh dài khác, bộ đệm KV tái sử dụng có thể là phần quan trọng để cải thiện độ trễ, giảm sử dụng GPU và hạ chi phí suy luận.