Cách chạy Kimi K2.5 trên máy cục bộ

Vận hành một mô hình quy mô nghìn tỷ tham số như Kimi K2.5 thường đòi hỏi cụm multi-GPU khổng lồ và ngân sách hạ tầng tương ứng, thường vượt quá $40/giờ. Tuy nhiên, với công cụ tối ưu phù hợp, bạn có thể chạy mô hình tối tân này mà không phải chi quá tay.

Trong hướng dẫn này, tôi sẽ chỉ bạn cách chạy Kimi K2.5 trên máy cục bộ bằng một GPU NVIDIA H200 duy nhất trên RunPod. Bằng cách tận dụng llama.cpp cho suy luận hiệu quả và kết nối nó với Kimi CLI, bạn có thể bỏ qua hạ tầng doanh nghiệp phức tạp và bắt đầu xây dựng phần mềm cấp cao ngay lập tức.

Kimi K2.5 là gì?

Kimi K2.5 là một mô hình ngôn ngữ lớn mã nguồn mở tối tân, được thiết kế cho suy luận nâng cao, lập trình, và sinh văn bản chất lượng cao. Được phát triển bởi Moonshot AI, đây là mô hình ở quy mô nghìn tỷ tham số, hướng tới suy luận nâng cao, sinh mã chất lượng cao, và các tác vụ viết tổng quát mạnh mẽ. 

Trải nghiệm thực tế cho thấy nó ngang tầm Claude Opus 4.5 ở nhiều quy trình, đặc biệt là lập trình, suy luận có cấu trúc, và sinh nội dung dài.

Một ưu điểm lớn của Kimi K2.5 là hoàn toàn mã nguồn mở. Điều này có nghĩa ai cũng có thể tải trọng số và tự chạy mô hình mà không cần dựa vào API trả phí hay nền tảng đóng. Dĩ nhiên, đánh đổi ở đây là vấn đề quy mô. 

Yêu cầu hệ thống và điều kiện tiên quyết phần cứng GPU cho Kimi K2.5

Phần này giải thích phần cứng, bộ nhớ và các điều kiện tiên quyết về GPU để chạy Kimi K2.5 cục bộ, bao gồm hiệu năng kỳ vọng trên một GPU H200.

Dung lượng đĩa

• Tối thiểu 300GB để chạy bản lượng tử hóa 1-bit
• Khuyến nghị có thêm không gian trống cho bộ đệm và log

Bộ nhớ (RAM + VRAM)

• Kinh nghiệm: RAM + VRAM ≈ kích thước bản lượng tử
• Khuyến nghị bộ nhớ hợp nhất 240GB+ để đạt 7+ token mỗi giây
• Thấp hơn mức này, mô hình vẫn chạy bằng offload sang đĩa nhưng hiệu năng có thể giảm xuống dưới 2 token mỗi giây

Yêu cầu GPU

• Bản 1.8-bit (UD-TQ1_0) có thể chạy trên một GPU NVIDIA H200 duy nhất.
• Với 144GB VRAM và ~188GB RAM hệ thống, kỳ vọng khoảng 7 token mỗi giây
• Bản đầy đủ (~630GB) thường cần 4× GPU NVIDIA H200

Trình điều khiển GPU và CUDA

• GPU NVIDIA với driver mới
• Khuyến nghị CUDA Toolkit 12.x
• Đảm bảo nvidia-smi hoạt động trước khi tiếp tục

Thiết lập môi trường GPU trên RunPod cho Kimi K2.5

Giờ chúng ta sẽ thiết lập một GPU pod trên RunPod và chuẩn bị để chạy Kimi K2.5.

Bắt đầu bằng cách tạo pod mới trong RunPod và chọn GPU NVIDIA H200. Với container image, chọn mẫu PyTorch mới nhất vì đã bao gồm hầu hết phụ thuộc CUDA và học sâu cần thiết. Sau khi chọn mẫu, bấm Edit để điều chỉnh thiết lập mặc định của pod.

Cập nhật cấu hình lưu trữ như sau:

• Đặt persistent volume disk thành 500GB
• Đặt kích thước đĩa container thành 50GB

Tiếp theo, mở thêm một cổng:

• Thêm cổng 8080 trong Expose HTTP Ports

Chúng ta mở cổng 8080 để có thể truy cập máy chủ và Web UI của llama.cpp trực tiếp từ trình duyệt, tại chỗ hoặc từ xa, sau khi máy chủ chạy.

Sau khi lưu các thiết lập này, hãy triển khai pod. Dù chỉ với một GPU, chạy mô hình như Kimi K2.5 vẫn tốn kém, nhưng RunPod mang lại lựa chọn tiết kiệm đáng kể so với các nhà cung cấp đám mây truyền thống.

Khi pod sẵn sàng, khởi chạy giao diện Jupyter Lab. Từ Jupyter Lab, mở một phiên Terminal. 

Dùng terminal bên trong Jupyter thuận tiện vì bạn có thể mở nhiều phiên terminal tức thì mà không cần quản lý các kết nối SSH riêng.

Trước tiên, xác minh trình điều khiển GPU và CUDA đã cài đúng bằng cách chạy:

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

Nếu mọi thứ đã thiết lập đúng, bạn sẽ thấy GPU H200 với khoảng 144GB VRAM khả dụng.

Tiếp theo, cài các gói Linux cần thiết để build llama.cpp từ mã nguồn:

sudo apt-get update
sudo apt-get install -y build-essential cmake curl git libcurl4-openssl-devĐược hỗ trợ bởi

Cài đặt llama.cpp với hỗ trợ CUDA cho Kimi K2.5

Chúng ta sẽ build llama.cpp từ mã nguồn vì nó nhanh, gọn nhẹ và cho hiệu năng tốt nhất trên GPU H200.

llama.cpp là một engine suy luận mã nguồn mở bằng C và C++ để chạy các mô hình ngôn ngữ lớn. Nó bao gồm máy chủ HTTP tích hợp tên là llama-server, cung cấp các endpoint REST và Web UI để tương tác với mô hình từ trình duyệt của bạn. 

Nó cũng hỗ trợ kernel CUDA tùy chỉnh và suy luận lai CPU cộng GPU, hữu ích khi mô hình không vừa hoàn toàn trong VRAM.

Đầu tiên, clone kho chính thức của llama.cpp:

git clone https://github.com/ggml-org/llama.cppĐược hỗ trợ bởi

Tiếp theo, cấu hình build với hỗ trợ CUDA bật. Chúng ta đặt đích kiến trúc CUDA 90, cần thiết cho GPU NVIDIA H200:

cmake /workspace/llama.cpp -B /workspace/llama.cpp/build \
  -DGGML_CUDA=ON \
  -DBUILD_SHARED_LIBS=OFF \
  -DCMAKE_CUDA_ARCHITECTURES=90Được hỗ trợ bởi

Giờ biên dịch binary llama-server. Máy chủ này sẽ được dùng để chạy Kimi K2.5 và mở endpoint HTTP cùng Web UI:

cmake --build /workspace/llama.cpp/build -j --clean-first --target llama-serverĐược hỗ trợ bởi

Khi build xong, sao chép binary tới vị trí thuận tiện:

cp /workspace/llama.cpp/build/bin/llama-server /workspace/llama.cpp/llama-serverĐược hỗ trợ bởi

Cuối cùng, xác minh binary tồn tại và đã build thành công:

ls -la /workspace/llama.cpp | sed -n '1,60p'Được hỗ trợ bởi

Tải mô hình GGUF Kimi K2.5 từ Hugging Face bằng Xet

Giờ chúng ta sẽ tải mô hình GGUF Kimi K2.5 từ Hugging Face bằng Xet, giúp tải nhanh hơn đáng kể cho các tệp mô hình lớn.

Trước tiên, cài các công cụ chuyển tải của Hugging Face và Xet cần thiết:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transferĐược hỗ trợ bởi

Bật backend truyền tải tốc độ cao:

export HF_HUB_ENABLE_HF_TRANSFER=1Được hỗ trợ bởi

Tiếp theo, tải mô hình lượng tử hóa 1.8-bit (UD-TQ1_0) từ Hugging Face và lưu cục bộ. 

Chúng ta dùng bản lượng tử này vì cân bằng tốt nhất giữa chất lượng mô hình và tính khả thi phần cứng, cho phép Kimi K2.5 chạy trên một GPU H200 bằng cách offload một phần mô hình sang RAM hệ thống mà vẫn giữ tốc độ suy luận chấp nhận được.

hf download unsloth/Kimi-K2.5-GGUF \
  --local-dir /workspace/models/Kimi-K2.5-GGUF \
  --include "UD-TQ1_0/*"Được hỗ trợ bởi

Ngay cả khi không đăng nhập bằng token truy cập Hugging Face, bạn vẫn có thể thấy tốc độ tải 800 MB mỗi giây hoặc cao hơn trên RunPod.

Trong trường hợp của chúng tôi, tải xong trong khoảng 6 phút. Thời gian thực tế có thể khác tùy băng thông mạng và hiệu năng đĩa. 

Chạy Kimi K2.5 cục bộ bằng máy chủ llama.cpp

Khi đã tải mô hình và build llama.cpp với hỗ trợ CUDA, chúng ta có thể khởi chạy Kimi K2.5 cục bộ bằng máy chủ HTTP của llama.cpp.

Chạy lệnh sau để khởi động llama-server:

/workspace/llama.cpp/llama-server \
  --model "/workspace/models/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf" \
  --alias "Kimi-K2.5" \
  --host 0.0.0.0 \
  --port 8080 \
  --threads 32 \
  --threads-batch 32 \
  --ctx-size 20000\
  --temp 0.8 \
  --top-p 0.95 \
  --min_p 0.01 \
  --fit on \
--prio 3 \
  --jinja \
  --flash-attn auto \
  --batch-size 1024\
  --ubatch-size 256Được hỗ trợ bởi

Ý nghĩa từng tham số:

• --model: Đường dẫn tới tệp mô hình GGUF cần nạp
• --alias: Tên thân thiện để nhận diện mô hình trong máy chủ và UI
• --host: Giao diện mạng gắn cho máy chủ (0.0.0.0 cho phép truy cập từ bên ngoài)
• --port: Cổng HTTP để mở máy chủ và Web UI của llama.cpp
• --threads: Số luồng CPU dùng cho suy luận và tiền xử lý
• --threads-batch: Số luồng CPU dùng cho xử lý batch prompt
• --ctx-size: Kích thước cửa sổ ngữ cảnh tối đa tính theo token
• --temp: Điều khiển mức ngẫu nhiên của đầu ra
• --top-p: Ngưỡng nucleus sampling để chọn token
• --min_p: Lọc các token có xác suất rất thấp
• --fit: Tự động cân bằng trọng số mô hình giữa VRAM và RAM hệ thống
• --prio: Đặt độ ưu tiên tiến trình cao hơn cho tải suy luận
• --jinja: Bật templating prompt dựa trên Jinja
• --flash-attn: Bật Flash Attention khi GPU hỗ trợ
• --batch-size: Số token xử lý mỗi batch trên GPU
• --ubatch-size: Kích thước micro-batch để cân bằng bộ nhớ và thông lượng

Khi khởi động, bạn sẽ thấy mô hình nạp khoảng 136GB vào bộ nhớ GPU, phần còn lại offload sang RAM hệ thống.

Lưu ý: Nếu máy chủ llama.cpp không nhận GPU và chạy trên CPU, hãy khởi động lại pod. Nếu vẫn lỗi, xóa bản build hiện tại và build lại llama.cpp với hỗ trợ CUDA bật.

Khi nạp xong, máy chủ in ra URL truy cập. Mở Web UI trong trình duyệt tại:

Lưu ý: Nếu bạn thấy lỗi khi chạy nvidia-smi, tiến trình có thể đã sập do áp lực bộ nhớ. Khởi động lại pod. Tất cả tệp mô hình vẫn nằm trên đĩa persistent.

Truy cập endpoint API Kimi K2.5 cục bộ qua Web UI

Khi máy chủ llama.cpp chạy, bạn có thể truy cập qua Web UI mở trên cổng 8080.

Để mở, vào bảng điều khiển RunPod, chọn pod đang chạy, và bấm liên kết cạnh cổng 8080. Thao tác này mở Web UI của llama.cpp trực tiếp trong trình duyệt.

Web UI cung cấp giao diện trò chuyện đơn giản, tương tự ChatGPT, nhưng chạy hoàn toàn trên chính phiên bản RunPod của bạn. URL này công khai. Bạn có thể chia sẻ liên kết với đồng đội hay cộng tác viên nếu cần.

Bắt đầu bằng cách gửi một prompt đơn giản tới mô hình Kimi K2.5 để xác minh mọi thứ hoạt động đúng. Trong trường hợp của chúng tôi, mô hình phản hồi ở khoảng 6 đến 7 token mỗi giây, điều này phù hợp với bản 1.8-bit chạy trên một H200 với offload một phần sang RAM. Đây là mức cơ bản tốt và xác nhận mô hình đang dùng GPU đúng cách.

Lưu ý: Web UI của llama.cpp không tách bạch rõ ràng phần suy luận và đầu ra cuối cùng, nên bạn có thể thấy hai phần trộn lẫn do vấn đề template. 

Cài đặt và thiết lập Kimi CLI cho suy luận Kimi K2.5 cục bộ

Kimi CLI là một tác nhân lập trình và suy luận dựa trên terminal do Moonshot AI phát triển. Nó được thiết kế để hỗ trợ các tác vụ lập trình, quy trình shell và thay đổi ở cấp dự án trực tiếp từ dòng lệnh. Khác với giao diện chat đơn giản, Kimi CLI có thể hoạt động trong thư mục làm việc của bạn, rất phù hợp với quy trình phát triển thực tế.

Đối với suy luận cục bộ, lợi thế then chốt của Kimi CLI là hỗ trợ API tương thích OpenAI. Điều này cho phép chúng ta trỏ trực tiếp tới llama-server đang chạy cục bộ, giúp Kimi K2.5 vận hành hoàn toàn trên phần cứng của chính chúng ta mà không phụ thuộc dịch vụ API lưu trú hay trả phí.

Bắt đầu bằng cách chạy script cài đặt chính thức:

curl -LsSf https://code.kimi.com/install.sh | bashĐược hỗ trợ bởi

Tiếp theo, thêm binary vào PATH để lệnh kimi khả dụng trong terminal:

export PATH="/root/.local/bin:$PATH"Được hỗ trợ bởi

Xác nhận cài đặt thành công:

kimi --versionĐược hỗ trợ bởi

Bạn sẽ thấy đầu ra tương tự kimi, version 1.5.

Tạo thư mục cấu hình dùng bởi Kimi CLI:

mkdir -p ~/.kimiĐược hỗ trợ bởi

Giờ hãy tạo tệp cấu hình. Tệp này chỉ định Kimi CLI coi máy chủ llama.cpp cục bộ của bạn như một nhà cung cấp tương thích OpenAI chạy tại http://127.0.0.1:8080/v1. Nó cũng đăng ký một mục mô hình cục bộ khớp với alias bạn chỉ định khi khởi chạy llama-server.

cat << 'EOF' > ~/.kimi/config.toml
[providers.local_llama]
type = "openai_legacy"
base_url = "http://127.0.0.1:8080/v1"
api_key = "sk-no-key-required"

[models.kimi_k25_local]
provider = "local_llama"
model = "Kimi-K2.5"
max_context_size = 20000
EOFĐược hỗ trợ bởi

Đảm bảo giá trị của model khớp chính xác với --alias dùng khi khởi động llama-server. Trường api_key là placeholder và không bắt buộc cho suy luận cục bộ.

Xây dựng trò chơi Rắn (Snake) tương tác bằng Kimi K2.5 và Kimi CLI

Trong phần này, chúng ta sẽ dùng Kimi CLI kết nối với máy chủ Kimi K2.5 cục bộ để one-shot một trò chơi Snake hoàn chỉnh bằng vibe coding.

Đầu tiên, tạo thư mục dự án mới và di chuyển vào đó:

mkdir -p /workspace/snake-game
cd /workspace/snake-gameĐược hỗ trợ bởi

Tiếp theo, khởi chạy Kimi CLI:

kimiĐược hỗ trợ bởi

Khi Kimi CLI khởi chạy, gõ /model và chọn mô hình Kimi K2.5 cục bộ mà chúng ta đã cấu hình trước đó. Bạn sẽ thấy Kimi-K2.5 được liệt kê là mô hình khả dụng.

Giờ hãy nhắc Kimi tạo trò chơi. Dùng chỉ dẫn đơn giản, trực tiếp như sau:

"Create a simple Snake game as a single self-contained file named index.html."Được hỗ trợ bởi

Kimi sẽ phác thảo kế hoạch và xin phê duyệt của bạn. Đọc kỹ và chấp thuận. 

Sau khi phê duyệt, Kimi sẽ tạo đầy đủ tệp index.html, bao gồm HTML, CSS và JavaScript, tất cả trong một nơi.

Khi tệp đã tạo, hãy tải xuống hoặc sao chép về máy và mở trong trình duyệt. Trò chơi sẽ chạy ngay.

• Nhấn phím cách để bắt đầu
• Dùng các phím mũi tên để điều khiển rắn

Kết quả là một trò Snake hoạt động đầy đủ với chuyển động mượt, hình ảnh sạch và lối chơi cổ điển. 

Trò chơi ghi nhận điểm cao, kết thúc khi bạn đâm vào tường, và cho phép khởi động lại bằng cách nhấn phím cách.

Độ hoàn thiện đáng ngạc nhiên chỉ với một prompt, là minh chứng tuyệt vời cho khả năng tạo của Kimi K2.5 khi kết hợp với Kimi CLI và thiết lập suy luận cục bộ.

Tổng kết

Thành thật mà nói, việc xây dựng một trò chơi hoàn chỉnh chỉ bằng một prompt one-shot gây nhiều bực bội hơn mong đợi. 

Dù Kimi K2.5 rõ ràng có khả năng, mô hình thường chật vật trong việc quyết định khi nào nên dừng lặp một tác vụ. Trên thực tế, nó có xu hướng “làm quá” vấn đề.

Ví dụ, khi được yêu cầu xây trò Snake bằng Pygame, nó có thể quay lại triển khai HTML, và khi yêu cầu HTML, lại chuyển về cách tiếp cận bằng Python. 

Sự qua lại này khiến bạn thường phải can thiệp nhiều lần để giữ mô hình bám sát ý định.

Một phần lớn hành vi này đến từ lượng tử hóa 1.8-bit. Dù chế độ 1-bit và dưới 2-bit giúp chạy mô hình cực lớn trên phần cứng hạn chế, chúng đi kèm đánh đổi. 

Mô hình vẫn có thể tạo phản hồi mạch lạc, nhưng gặp khó hơn trong việc kết thúc tác vụ, suy luận tầm xa, lập kế hoạch có cấu trúc và gọi hàm. Đây chính là những mảng quan trọng nhất cho quy trình kiểu tác nhân và các tác vụ lập trình nhiều bước.

Thực tế, Kimi K2.5 thực sự tỏa sáng ở độ chính xác cao hơn, như 4-bit trở lên. Ở mức đó, khả năng lập kế hoạch cải thiện rõ rệt và mô hình hành xử dự đoán hơn. 

Điểm trừ thì rõ ràng. Độ chính xác cao cần nhiều RAM và VRAM hơn đáng kể, khiến nhiều thiết lập cục bộ khó đáp ứng. Xét riêng tỷ lệ kích thước-so-hiệu năng ở độ chính xác thấp, các mô hình như GLM 4.7 hiện mang lại trải nghiệm mượt hơn cho nhiều người dùng.

Dù vậy, nếu bỏ qua ràng buộc phần cứng và chạy Kimi K2.5 ở độ chính xác cao hơn hoặc qua API lưu trú, mô hình thực sự ấn tượng. Chiều sâu suy luận, chất lượng sinh mã và khả năng xử lý ngữ cảnh dài đủ mạnh để thay thế mô hình sở hữu độc quyền trong nhiều quy trình. 

Thực tế, khi dùng qua Kimi AI API, nó đủ tốt để biện minh cho việc chuyển cả quy trình vibe-coding sang đó.

Để tiếp tục tìm hiểu các khái niệm đã đề cập, tôi khuyến nghị các tài nguyên sau: 

• Lượng tử hóa cho Mô hình Ngôn ngữ Lớn (LLM): Giảm kích thước mô hình AI hiệu quả
• Cách chạy GLM-4.7 cục bộ với llama.cpp: Hướng dẫn hiệu năng cao
• Phát triển Mô hình Ngôn ngữ Lớn