Kimi K2 lokaal draaien: complete setup & troubleshooting

Kimi K2, ontwikkeld door Moonshot AI, is een state-of-the-art Mixture-of-Experts (MoE) taalmodel. Het blinkt uit in frontier-kennis, redeneren en coderen, en is speciaal geoptimaliseerd voor agentic-capaciteiten, waaronder toolgebruik en autonoom probleemoplossen.

Zoals we verkennen in onze Kimi K2-gids, behaalt het model uitstekende benchmarkresultaten, waardoor het het beste open-source taalmodel voor algemeen gebruik is. We maken het Deepseek R1-moment mee, en om dat te vieren laat ik je zien hoe je dit enorme model van 1 terabyte op een enkele GPU draait. 

We leren hoe je de Runpod-machine instelt, llama.cpp installeert en het model sneller downloadt. Daarnaast draaien we het model met de llama.cpp CLI, waarbij we model-lagen naar het RAM offloaden. Tot slot behandelen we veelvoorkomende problemen die optreden bij het draaien van deze modellen. Je vindt ook onze gids voor de nieuwe Kimi K2.5 met Agent Swarm.

Runpod instellen

Ga naar de Runpod GPU Cloud en maak een cloud aan met de A100 SXM-machine met de Python Container Image versie 2.8.0. 

Vergroot daarna de containeropslag naar 300 GB via de optie Pod bewerken. 

Als alles is ingesteld, zie je dat je 300 GB opslag hebt, wat voldoende is omdat ons 1-bit gequantiseerde model 250 GB opslag vereist. 

llama.cpp installeren

1. Klik op de knop Connect en start de Jupyter Lab-instantie. Maak een nieuw notebook aan en installeer de benodigde Linux-tools, zoals cmake en curl.

!apt-get update
!apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -yMogelijk gemaakt door

2. Ga naar de rootmap. We gebruiken de workspace-map niet. De reden hiervoor is om zowel de download- als laadsnelheden van het model te verhogen. In de troubleshooting-sectie aan het einde lees je er meer over.

%cd ..Mogelijk gemaakt door

3. Clone de nieuwste versie van de llama.cpp-repository.

!git clone https://github.com/ggml-org/llama.cppMogelijk gemaakt door

4. Stel de buildopties in. We maken de build voor een GPU-machine. Als je CPU-inferentie wilt gebruiken, verander dan DGGML_CUDA=ON naar DGGML_CUDA=OFF.

!cmake llama.cpp -B llama.cpp/build \
  -DBUILD_SHARED_LIBS=OFF \
  -DGGML_CUDA=ON \
  -DLLAMA_CURL=ON \
  -DCMAKE_CUDA_ARCHITECTURES="80;90" \
  -DCMAKE_CUDA_FLAGS="-Wno-deprecated-gpu-targets"Mogelijk gemaakt door

5. We gebruiken het cmake-commando om de tools te bouwen: llama-quantize, llama-cli, llama-gguf-split en llama-mtmd-cli.

!cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cliMogelijk gemaakt door

6. Kopieer alle buildtools naar de hoofdrepository zodat we er eenvoudig bij kunnen.

!cp llama.cpp/build/bin/llama-* llama.cppMogelijk gemaakt door

Kimi K2 snel downloaden met xnet

De gequantiseerde versies van het Kimi K2-model door Unsloth ondersteunen xnet, waarmee downloaden en uploaden 4 keer sneller gaat dan met Git LFS. Installeer lokaal de nieuwste versie van huggingface_hub en hf_transfer om het te activeren:

!pip install huggingface_hub hf_transferMogelijk gemaakt door

Gebruik de snapshot_download-API om alleen de 1-bit gequantiseerde GGUF-modelfiles van de repository te downloaden:

import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0"

from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/Kimi-K2-Instruct-GGUF",
    local_dir = "/unsloth/Kimi-K2-Instruct-GGUF",
    allow_patterns = ["*UD-TQ1_0*"],
)Mogelijk gemaakt door

Het downloaden duurt even, afhankelijk van je internet- en opslag­snelheid.

Bij ons ging het supersnel omdat we snellere opslagoplossingen hebben met xnet ingeschakeld. 

Kimi K2 lokaal draaien

Tijd om onze gequantiseerde versie van het model te testen. Dit is het deel waar ik de meeste tijd kwijt was aan debuggen, omdat ik het op één GPU probeer te draaien. Hoewel dit niet onmogelijk is, brengt het verschillende problemen met zich mee rond het laden en uitvoeren van het model.

We gebruiken alle CPU-threads en maximaliseren het laden van lagen naar de GPU, wat het offloaden naar de CPU inhoudt van zowel up- als down-projection Mixture of Experts-lagen. 

Hier is het commando dat we in de terminal draaien en dat soepel werkt:

./llama.cpp/llama-cli \
  --model /unsloth/Kimi-K2-Instruct-GGUF/UD-TQ1_0/Kimi-K2-Instruct-UD-TQ1_0-00001-of-00005.gguf \
  --cache-type-k q4_0 \
  --threads -1 \
  --n-gpu-layers 99 \
  --temp 0.6 \
  --min_p 0.01 \
  --ctx-size 16384 \
  --seed 3407 \
  -ot ".ffn_(up|down)_exps.=CPU" \
  --prompt "Hey"Mogelijk gemaakt door

Het laden van het volledige model duurde bijna een minuut. Zoals we zien past het model perfect op de machine.

Als je je Runpod-dashboard bekijkt, zie je dat je CPU-gebruik hoog is en zowel RAM- als VRAM-geheugen wordt benut.

Na ongeveer vier minuten laden en opwarmen ben je klaar om het model vragen te stellen.

Ik stelde een eenvoudige vraag: "Wat is moesson? Schrijf het antwoord in één regel."

Het genereren duurde bijna vijf minuten. 

Ik heb onderzocht waarom de tokengeneratie traag is, en het blijkt dat de GPU alleen als geheugen wordt gebruikt terwijl alle verwerking door de CPU gebeurt. Om dit te verhelpen, moet je meer lagen naar de GPU offloaden, wat betekent dat je 2 A100-machines nodig hebt.

Problemen oplossen

In deze sectie bespreken we de meest voorkomende problemen bij het draaien van een groot model op één GPU en hoe je ze kunt oplossen.

1. VRAM vs compute begrijpen

Als je 95% GPU-RAM-gebruik ziet, 0% GPU-compute en 99% CPU-belasting, betekent dit meestal dat de VRAM fungeert als geheugenopslag voor het model, terwijl de daadwerkelijke verwerking op de CPU plaatsvindt.

Zelfs sterk gequantiseerde en kleinere 1-bit modellen moeten nog steeds in het geheugen worden geladen, wat bijdraagt aan VRAM-gebruik. GPU-gebruik voor berekeningen zal pas plaatsvinden als je meer lagen naar de VRAM offloadt.

2. Trage tokengeneratie aanpakken

Om de snelheid van tokengeneratie te verbeteren, moet je meer lagen van het model naar de GPU offloaden. Overweeg misschien een multi-GPU-setup, zoals drie A100-GPU’s. Stel de temperatuur in op 0,6 om herhaling en incoherentie in de gegenereerde tekst te verminderen.

3. Hardwarevereisten en prestaties

Als je beperkte VRAM of RAM hebt, kun je nog steeds 1-bit modellen op een consumenten-CPU draaien. De tokengeneratie zal echter erg traag zijn (bijv. 1 token per 20 seconden).

De enige harde eis voor het draaien van 1-bit modellen is dat je totale schijfruimte + RAM + VRAM groter dan of gelijk aan 250 GB is.

Voor optimale prestaties (5+ tokens/seconde) heb je minstens 250 GB aan unified memory of een gecombineerde 250 GB aan RAM en VRAM nodig.

4. Trage downloads oplossen

Installeer de nieuwste versie van huggingface_hub en hf_transfer om toegang te krijgen tot "xnet-snelheid", die 4x sneller is dan eenvoudige Git LFS.

Om de opslag en het laden van geshardde GGUF-bestanden te optimaliseren, is het aan te raden een container disk te gebruiken voor opslag in plaats van een container volume. Container volumes kunnen namelijk zorgen voor traag downloaden en langzaam modelladen.

5. Traag laden van het model oplossen

Traag modelladen duidt er vaak op dat je een zeer groot model laadt. Modellen laden vanaf netwerkopslag kan het laadproces aanzienlijk vertragen. Gebruik altijd een lokale M.2-SSD om je modellen op te slaan. M.2-SSD’s bieden veel hogere lees-/schrijfsnelheden dan traditionele harde schijven of netwerkopslag, waardoor laadtijden drastisch dalen. 

Als er niet genoeg RAM is om het model te laden, kan het besturingssysteem beginnen met swappen naar schijf (een swapbestand), wat veel langzamer is dan RAM en een bottleneck veroorzaakt. Probeer een multi-GPU-setup met meer RAM te hebben.

Conclusie

Het draaien van gequantiseerde versies van Kimi K2 kan nog steeds uitdagingen opleveren, omdat tools zoals llama.cpp zich actief ontwikkelen om gelijke tred te houden met de nieuwste updates van het model. Verwacht de komende weken verbeterde oplossingen die tokengeneratie naar GPU’s verschuiven voor betere prestaties, in plaats van uitsluitend op CPU’s te vertrouwen.

Bovendien was dit voor mij een waardevolle leerschool. Ik heb inzicht gekregen in hoe de open-sourcegemeenschap samenwerkt om deze modellen zo efficiënt mogelijk te optimaliseren en uit te rollen.

Kimi K2 springt eruit als een van de beste open-source modellen, dicht in de buurt van modellen als DeepSeek R1, met state-of-the-art prestaties in frontier-kennis, wiskunde en coderen onder non-thinking modellen. 

Het is vooral sterk in toolselectie en agentic-taken, en vormt een kosteneffectief alternatief voor premium modellen zoals Claude 4 Sonnet voor codeerprojecten of vibe coding.

Je kunt de gequantiseerde versie van Kimi K2 intern inzetten met deze gids. Llama.cpp laat je taalmodellen als een API aanbieden met OpenAI-compatibiliteit. Wil je blijven leren, bekijk dan zeker onze Kimi K2-gids met voorbeelden. Als je meer wilt leren over agentic AI, volg dan zeker onze nieuwe cursus over het bouwen van multi-agentsystemen met LangGraph.