Cara Menjalankan Kimi K3 Lokal (dan Kapan Sebaiknya Tidak)

Moonshot AI merilis bobot terbuka Kimi K3 pada 27 Juli. Penghitung unduhan di Hugging Face sudah mendekati 100.000, didorong oleh penawaran yang kuat: model 2,8 triliun parameter yang mengalahkan Claude Opus 4.8 di setiap benchmark yang diterbitkan Moonshot, dan kini dapat Anda host sendiri.

Coba Apidog hari ini

Namun, menjalankan K3 secara lokal membutuhkan perencanaan kapasitas yang serius. Inferensi presisi penuh memerlukan sekitar 1,57 TB ruang disk, sedangkan bobot MXFP4 resmi saja berukuran 594 GB. Pada skala ini, “lokal” berarti workstation besar atau infrastruktur GPU, bukan laptop seperti saat menjalankan Llama 8B.

Panduan ini menjelaskan cara memilih jalur deployment Kimi K3, menjalankannya dengan vLLM atau llama.cpp, serta menghubungkan endpoint lokal ke workflow API menggunakan Apidog.

Apa yang Anda unduh

Sebelum menyiapkan server, pahami bentuk modelnya. Untuk konteks lebih lengkap, baca Apa Itu Kimi K3?. Ringkasnya:

• 2,8T parameter total, 104B aktif per token. K3 adalah model Mixture-of-Experts (MoE) dengan 896 pakar. Setiap token menggunakan 16 pakar terpilih dan 2 pakar bersama, sehingga komputasi per token jauh lebih kecil daripada jumlah parameter total.
• 93 lapisan: 69 lapisan Kimi Delta Attention (KDA) dan 24 lapisan Gated MLA. KDA membantu membuat konteks hingga 1 juta token lebih praktis.
• Visi bawaan melalui encoder MoonViT-V2 berparameter 401M. Bobot yang dirilis mendukung input teks, gambar, dan video.
• Bobot MXFP4 dengan aktivasi MXFP8. Moonshot menggunakan pelatihan sadar kuantisasi. Artinya, rilis 4-bit adalah format inference yang memang ditargetkan, bukan sekadar varian tambahan.
• Mode reasoning saja. K3 selalu melakukan penalaran sebelum menjawab, dengan tingkat usaha rendah, tinggi, dan maksimal. Tidak ada mode instan.

Bobot tersedia di bawah Lisensi Kimi K3 pada repositori Hugging Face. Terima lisensinya terlebih dahulu, lalu unduh bobot menggunakan huggingface-cli.

huggingface-cli download moonshotai/Kimi-K3 \
  --local-dir ./Kimi-K3

Pada koneksi 1 Gbps, siapkan waktu sekitar 80–90 menit untuk mengunduh 594 GB bobot MXFP4.

Opsi 1: Sajikan dengan vLLM atau SGLang di kelas pusat data

Moonshot merekomendasikan vLLM, SGLang, dan TokenSpeed. Untuk deployment awal, vLLM adalah jalur paling langsung karena kontribusi KDA prefill-cache sudah dikirim bersama bobot.

Jalankan server OpenAI-compatible dengan paralelisme tensor 8 GPU:

vllm serve moonshotai/Kimi-K3 \
  --tensor-parallel-size 8 \
  --max-model-len 131072

Gunakan konfigurasi ini sebagai titik awal, lalu sesuaikan berdasarkan beban kerja.

Checklist kapasitas

• GPU: secara realistis, gunakan node 8 GPU sebagai baseline untuk tensor parallelism. Moonshot mengevaluasi model pada kluster H20.
• Throughput: pada perangkat keras kelas B200, throughput di atas 100 token/detik dapat dicapai.
• Konteks: K3 mendukung hingga 1.048.576 token, tetapi cache KV pada konteks penuh sendiri membutuhkan sekitar 27 GB. Mulai dari 131072, ukur penggunaan memori dan latensi, lalu naikkan hanya bila benar-benar diperlukan.
• Sampling: default Moonshot menggunakan temperature=1.0 dan top_p=0.95. Untuk workload agen, pertahankan temperature=1.0 dan gunakan top_p=1.0.

Contoh request setelah server berjalan:

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "moonshotai/Kimi-K3",
    "messages": [
      {
        "role": "user",
        "content": "Jelaskan rencana migrasi API secara ringkas."
      }
    ],
    "temperature": 1.0,
    "top_p": 0.95
  }'

Pendekatan ini cocok jika “lokal” berarti infrastruktur milik Anda sendiri: data, log, dan kontrol kepatuhan tetap berada di lingkungan Anda. Namun, ini bukan deployment laptop, dan kuantisasi tidak mengubah kebutuhan hardware K3 menjadi ringan untuk penggunaan interaktif.

Opsi 2: Jalankan kuantisasi GGUF pada workstation besar

Unsloth menerbitkan konversi GGUF untuk pengguna llama.cpp. Kuantisasi dinamis mereka merupakan cara realistis untuk mengecilkan ukuran K3 di bawah rilis resmi.

Kuantisasi	Ukuran	Artinya
UD-IQ1_M	~345 GB	Batas bawah dengan kuantisasi dinamis 1-bit yang agresif.
UD-IQ1_S	~650 GB	Titik keseimbangan yang direkomendasikan Unsloth.
UD-Q4_K_XL	~1,55 TB	Mendekati presisi penuh.
UD-Q8_K_XL	~1,6 TB	Secara efektif tanpa kehilangan.

Aturan praktisnya: total RAM + VRAM sebaiknya kira-kira setara dengan ukuran file kuantisasi. Jika kapasitas memori lebih kecil, llama.cpp masih dapat berjalan melalui offloading, tetapi setiap GB yang tidak tersedia akan menurunkan kecepatan.

Untuk penggunaan praktis, Mac Studio dengan memori terpadu besar atau DGX Station berada di batas bawah yang masuk akal.

Contoh pemanggilan minimal llama.cpp, termasuk proyektor visi:

./llama.cpp/llama-cli \
  --model unsloth/Kimi-K3-GGUF/UD-IQ1_S/Kimi-K3-UD-IQ1_M-00001-of-00015.gguf \
  --mmproj unsloth/Kimi-K3-GGUF/mmproj-F16.gguf \
  --temp 1.0 \
  --top-p 0.95

Jika workstation Anda tidak memenuhi kebutuhan tersebut, jangan memaksakan K3. Daftar LLM lokal terbaik tahun 2026 mencakup model terbuka yang muat pada memori 24–128 GB dan dapat merespons secara real time. K3 1-bit dengan RAM yang tidak cukup tidak akan memberikan pengalaman itu.

Eksperimen M1 Max: bisa berjalan, tetapi sekitar 16 detik per token

Sebuah thread Hacker News mendokumentasikan K3 yang berjalan pada M1 Max 64 GB dengan streaming bobot dari SSD 2 TB, bukan menyimpan semuanya di memori.

Hasilnya menarik secara teknis, tetapi tidak ideal untuk penggunaan sehari-hari:

• K3 memiliki sekitar 115 GB parameter padat yang disentuh pada setiap token, ditambah sekitar 25 GB bobot pakar yang dirutekan per token.
• Bagian padat saja melebihi RAM mesin, sehingga SSD berfungsi sebagai memori yang jauh lebih lambat.
• Hasil pengujian berada di sekitar 16 detik per token. Beberapa konfigurasi bahkan melaporkan lebih dari satu menit per token.
• Throughput disk menjadi faktor utama. SSD era M1 lebih lambat daripada perangkat Apple Silicon terbaru, sementara streaming pakar melalui jaringan akan lebih lambat lagi.

Eksperimen ini membuktikan bahwa sparsity MoE dan mmap dapat menjalankan model 2,8T pada laptop. Namun, ini bukan setup yang tepat untuk penggunaan interaktif. Jika Anda membutuhkan respons K3 di MacBook, gunakan tingkat gratis atau API yang di-host.

Menyambungkan K3 lokal ke workflow API

Baik menggunakan vLLM maupun mode server llama.cpp, hasil akhirnya sama: endpoint HTTP yang kompatibel dengan OpenAI di localhost.

Anda dapat menerapkan workflow yang sama seperti saat menguji LLM lokal sebagai API.

1. Buat environment untuk endpoint lokal

Di Apidog, buat environment dengan variabel berikut:

base_url = http://localhost:8000/v1

Gunakan variabel tersebut pada request Anda:

POST {{base_url}}/chat/completions
Content-Type: application/json

Dengan pola ini, Anda dapat berpindah dari endpoint lokal ke endpoint yang di-host Moonshot tanpa mengubah struktur request—cukup ganti nilai base_url.

2. Inspeksi respons streaming dan reasoning

K3 selalu melakukan reasoning sebelum menghasilkan jawaban. Saat menggunakan streaming, respons dapat membawa konten penalaran sebelum jawaban akhir.

Tampilan debugging SSE di Apidog membantu Anda melihat event saat diterima. Gunakan ini untuk membandingkan dampak tingkat usaha reasoning terhadap:

• waktu token pertama,
• total latensi,
• jumlah token reasoning,
• struktur respons akhir.

3. Tambahkan assertion untuk kontrak API

Jangan hanya mengevaluasi kualitas jawaban secara manual. Tambahkan pengujian otomatis untuk memvalidasi hal-hal yang dapat diukur:

• status HTTP berhasil,
• skema respons tetap valid,
• field penggunaan token tersedia,
• latency masih dalam anggaran,
• konten jawaban akhir tidak kosong.

Contoh assertion konseptual:

pm.test("Respons berhasil", function () {
  pm.response.to.have.status(200);
});

const body = pm.response.json();

pm.test("Memiliki pilihan respons", function () {
  pm.expect(body.choices).to.be.an("array").that.is.not.empty;
});

pm.test("Memiliki data penggunaan token", function () {
  pm.expect(body.usage).to.exist;
});

Dengan assertion seperti ini, perubahan akibat pertukaran kuantisasi atau peningkatan inference engine akan muncul sebagai pengujian gagal, bukan laporan dari pengguna.

4. Gunakan mock saat GPU sedang memuat model

Model 594 GB membutuhkan waktu untuk dimuat. Rekam respons K3 nyata satu kali, lalu gunakan server mock untuk mengembalikan respons tersebut selama tim frontend bekerja.

Dengan pendekatan ini, pengembangan UI tidak perlu menunggu server inference siap. Unduh Apidog untuk menyiapkan mock dan pengujian secara gratis; keduanya dapat digunakan dengan server yang kompatibel dengan OpenAI.

Format request-nya mengikuti pola yang dijelaskan dalam panduan API Kimi K3, sehingga pengujian terhadap API yang di-host dapat langsung dipindahkan ke deployment lokal.

Jadi, haruskah Anda menjalankan K3 secara lokal?

Gunakan tabel berikut untuk memilih pendekatan.

Situasi Anda	Rekomendasi
Node 8+ GPU, membutuhkan kedaulatan data atau kepatuhan	Ya. Gunakan vLLM dengan tensor parallelism dan bobot MXFP4.
Workstation dengan RAM/VRAM 350 GB+	Bisa dilakukan. Gunakan GGUF 1-bit Unsloth dengan ekspektasi throughput yang realistis.
Mac atau PC dengan memori 64–128 GB	Tidak direkomendasikan. Anda akan mendapatkan detik per token, bukan token per detik.
Hanya ingin memakai K3 dalam produk	Gunakan API yang di-host; kompatibel dengan OpenAI dan Anthropic.

Intinya, bobot terbuka K3 penting karena Anda dapat mengaudit, menyetel, dan meng-host sendiri model kelas frontier. Bukan berarti sebagian besar developer harus menjalankannya di perangkat pribadi.

Jika tim Anda memiliki hardware yang memadai, jalur vLLM sudah dapat digunakan dan berkinerja baik. Untuk tim lain, rilis terbuka tetap bermanfaat melalui akses hosted yang lebih kompetitif dan penyedia pihak ketiga yang dapat menawarkan model tersebut.

Apa pun backend yang Anda pilih, perlakukan endpoint K3 seperti API produksi: validasi skema, inspeksi streaming, ukur latensi, dan gunakan mock agar pengembangan tetap berjalan ketika model sedang dimuat atau melakukan reasoning.