Peut-on exécuter Kimi K3 en local ? Guide matériel, GGUF et vLLM (2026)
Oui, Kimi K3 peut tourner en local, car Moonshot AI publie ses poids sur Hugging Face, mais c'est un modèle de 2 800 milliards de paramètres : « en local » signifie environ 610 Go de RAM et de VRAM combinées pour le plus petit GGUF 1 bit, ou un nœud Blackwell complet de 8 GPU pour les poids natifs. Sur une seule station de travail avec moins de mémoire, il se chargera quand même depuis le disque, mais très lentement. Pour la plupart des développeurs, exécuter K3 sur des GPU louées ou l'appeler via une API revient moins cher que d'acheter du matériel.
Ce guide couvre tout ce qu'il faut pour exécuter Kimi K3 sur vos propres machines au 24 octobre 2026 : la licence, les besoins exacts en mémoire par quantification, les commandes llama.cpp et vLLM pas à pas, l'appel de votre serveur local depuis le code et une comparaison des coûts avec les GPU louées et les API hébergées. Les chiffres proviennent de la fiche du modèle de Moonshot AI, des recettes officielles de vLLM et SGLang et de la documentation d'Unsloth ; tout ce que nous avons estimé est signalé comme une estimation.
Kimi K3 en bref
| Caractéristique | Valeur |
|---|---|
| Développeur | Moonshot AI |
| Poids | moonshotai/Kimi-K3 sur Hugging Face |
| Architecture | Mélange d'experts : 2,8T paramètres au total, 104B actifs par token |
| Experts | 896 experts routés, 16 sélectionnés par token, plus 2 partagés |
| Couches | 93 (69 couches d'attention linéaire KDA et 24 couches MLA à porte) |
| Fenêtre de contexte | 1 048 576 tokens |
| Entrées | Texte et images (encodeur visuel MoonViT-V2, 401M paramètres) |
| Précision native | Poids MXFP4 avec activations MXFP8 (entraînement tenant compte de la quantification) |
| Raisonnement | Réflexion toujours active ; reasoning_effort low, high ou max (max par défaut) |
| Licence | Kimi K3 License (MIT modifiée) |
Source : la fiche du modèle Kimi K3, consultée le 24 octobre 2026.
Deux remarques avant de commencer. D'abord, Moonshot AI propose désormais Kimi K3.1 Pro sur son API et qualifie K3 de « modèle phare de la génération précédente », mais au 24 octobre 2026 les poids ouverts les plus récents sur Hugging Face restent ceux de Kimi K3 : c'est donc K3 que vous pouvez exécuter vous-même. Ensuite, K3 fonctionne uniquement en mode réflexion : votre client doit renvoyer reasoning_content et les appels d'outils dans les conversations multi-tours, comme l'indique la fiche du modèle.
Peut-on utiliser Kimi K3 commercialement ?
La Kimi K3 License est de type MIT avec deux conditions supplémentaires, selon le fichier de licence sur Hugging Face (octobre 2026) :
- Si vous proposez K3 dans une activité de modèle en tant que service avec plus de 20 millions de dollars de revenus sur les 12 derniers mois, vous devez conclure un accord distinct avec Moonshot AI.
- Si votre produit compte plus de 100 millions d'utilisateurs actifs mensuels ou plus de 20 millions de dollars de revenus mensuels, vous devez afficher « Kimi K3 » dans l'interface utilisateur.
L'usage interne au sein de votre entreprise n'est pas limité par ces conditions. Pour la plupart des startups et des équipes, l'usage local ou auto-hébergé est autorisé ; lisez le texte complet de la licence avant de mettre en production.
De quel matériel Kimi K3 a-t-il besoin ?
Quantifications GGUF (llama.cpp)
Unsloth publie des quantifications GGUF dynamiques. Sa règle empirique : votre RAM plus votre VRAM doivent au moins égaler la taille de la quantification, sinon le modèle sera déchargé sur disque et tournera beaucoup plus lentement.
| Quantification | Mémoire nécessaire (RAM + VRAM) | Remarques |
|---|---|---|
1 bit dynamique S (UD-IQ1_S) |
environ 610 Go | 594 Go de fichiers ; l'équilibre taille/qualité recommandé par Unsloth, environ 79 % de précision top-1 |
| 1 bit dynamique M | environ 665 Go | |
| 2 bits dynamique XXS | environ 726 Go | |
| 2 bits dynamique XL | environ 880 Go | Unsloth indique environ 90 % de précision pour son 2 bits dynamique de 861 Go |
Q8 (UD-Q8_K_XL, sans perte) |
environ 1,6 To | 1,56 To de fichiers ; équivalent aux poids natifs MXFP4 |
Unsloth annonce environ 20 tokens par seconde en génération lorsque la quantification 1 bit tient sur des GPU B200. Sur des machines surtout CPU qui gardent l'essentiel des poids en RAM système, attendez-vous à des vitesses bien plus faibles ; nous ne les avons pas mesurées, considérez donc tout chiffre comme une estimation tant que vous n'avez pas testé votre propre matériel.
Concrètement, qu'est-ce que cela signifie ? Quelques configurations locales réalistes :
| Configuration | Le 1 bit (610 Go) tient-il ? | À quoi s'attendre (estimation) |
|---|---|---|
| PC gaming : 1x RTX 4090 (24 Go) + 128 Go de RAM | Non | Ne tourne qu'avec un fort déchargement sur disque ; très lent, utile uniquement pour des tests |
| Station de travail ou serveur : 1-2 GPU + 768 Go de DDR5 | Oui | Utilisable pour des expériences mono-utilisateur à faible vitesse |
| Serveur multi-GPU avec 8x GPU de 80-141 Go | Oui, en VRAM | Vitesse interactive pour un ou quelques utilisateurs |
| Nœud 8x B300 / classe GB300 | Poids natifs MXFP4 | Service en production avec vLLM ou SGLang |
Poids natifs (vLLM et SGLang)
Pour les poids officiels, la recette vLLM pour Kimi K3 demande au moins 8x GPU GB300 (ou au moins 8x MI355X ou MI350X sur AMD ROCm), avec l'image vllm/vllm-openai:kimi-k3, qui nécessite CUDA 13 et le pilote NVIDIA r580 ou ultérieur. Le cookbook SGLang liste des formats de nœud comme B300 1x8, GB300 2x4, B200 2x8, GB200 4x4, H200 2x8, H100 4x8 et MI350X/MI355X 1x8, mais en octobre 2026 seule la configuration B300 1x8 est marquée comme vérifiée. Autrement dit, un déploiement sur H100 nécessite quatre nœuds de 8 GPU, ce qui est hors de portée de presque tous ceux qui l'exécutent « en local ».
Pour aller plus loin sur le dimensionnement, consultez notre guide des besoins en mémoire GPU des LLM et notre guide de déploiement vLLM en parallélisme d'experts.
Exécuter Kimi K3 en local avec llama.cpp (GGUF)
Ces étapes suivent le guide d'Unsloth. La prise en charge de la vision de K3 nécessite pour l'instant le fork d'Unsloth de llama.cpp ; l'usage texte seul suit les mêmes étapes.
1. Compilez llama.cpp. Utilisez -DGGML_CUDA=OFF si vous n'avez pas de GPU NVIDIA.
git clone https://github.com/unslothai/llama.cpp
cd llama.cpp
git fetch origin pull/48/head:kimi-k3-fullsize-vision
git checkout kimi-k3-fullsize-vision
cd ..
cmake llama.cpp -B llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first \
--target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
2. Téléchargez la quantification 1 bit (environ 594 Go) et le projecteur visuel. Vérifiez d'abord l'espace disque libre.
pip install -U huggingface_hub
df -h . # need roughly 650 GB free
hf download unsloth/Kimi-K3-GGUF \
--local-dir unsloth/Kimi-K3-GGUF \
--include "*mmproj-BF16*" \
--include "*UD-IQ1_S*"
3. Discutez dans le terminal. Utilisez l'échantillonnage recommandé par Moonshot : temperature 1.0 et top_p 0.95 (top_p 1.0 pour les tâches agentiques).
FIRST=$(ls unsloth/Kimi-K3-GGUF/UD-IQ1_S/*00001-of-*.gguf | head -1)
./llama.cpp/llama-cli --model "$FIRST" \
--mmproj unsloth/Kimi-K3-GGUF/mmproj-BF16.gguf \
--temp 1.0 --top-p 0.95
4. Servez une API compatible OpenAI. llama-server expose /v1/chat/completions. Une taille de contexte plus petite économise de la mémoire pour le cache KV.
./llama.cpp/llama-server --model "$FIRST" \
--mmproj unsloth/Kimi-K3-GGUF/mmproj-BF16.gguf \
--ctx-size 32768 --temp 1.0 --top-p 0.95 \
--host 127.0.0.1 --port 8080
Servir Kimi K3 avec vLLM (nœud complet)
Si vous possédez ou louez un nœud de 8 GPU compatible, vLLM vous offre un débit de production, l'appel d'outils et le contexte complet de 1M. La commande de base de la recette officielle :
docker run --gpus all --ipc=host -p 8000:8000 \
-v ~/.cache/huggingface:/root/.cache/huggingface \
vllm/vllm-openai:kimi-k3 \
moonshotai/Kimi-K3 --trust-remote-code \
--tensor-parallel-size 8 \
--tool-call-parser kimi_k3 --reasoning-parser kimi_k3 \
--enable-auto-tool-choice \
--max-model-len 1048576 \
--enable-prefix-caching --kv-cache-dtype fp8
La recette signale aussi que le format des appels d'outils est parfois mal formé : validez les arguments et réessayez en cas d'échec d'analyse. Notre guide de déploiement vLLM et notre guide d'inférence multi-GPU couvrent la supervision et le réglage.
Appeler votre serveur Kimi K3 local
llama-server (port 8080 ci-dessus) et vLLM (port 8000) parlent tous deux l'API OpenAI, donc n'importe quel SDK OpenAI fonctionne.
curl
curl -s http://127.0.0.1:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model":"moonshotai/Kimi-K3","temperature":1.0,"top_p":0.95,
"messages":[{"role":"user","content":"Write a bash one-liner that finds the 5 largest files in a directory."}]}'
Python
from openai import OpenAI
# Local vLLM server; use base_url="http://127.0.0.1:8080/v1" for llama-server
client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="local")
r = client.chat.completions.create(
model="moonshotai/Kimi-K3",
temperature=1.0, top_p=0.95,
messages=[{"role": "user", "content": "Explain MoE routing in 3 sentences."}],
)
msg = r.choices[0].message
print(getattr(msg, "reasoning_content", None)) # thinking trace, when the server returns it
print(msg.content)
Node.js
import OpenAI from "openai";
const client = new OpenAI({ baseURL: "http://127.0.0.1:8000/v1", apiKey: "local" });
const r = await client.chat.completions.create({
model: "moonshotai/Kimi-K3",
temperature: 1.0,
top_p: 0.95,
messages: [{ role: "user", content: "Give me a regex for ISO 8601 dates." }],
});
console.log(r.choices[0].message.content);
Dans les conversations multi-tours, ajoutez à l'historique le message de l'assistant avec son reasoning_content et ses éventuels tool_calls avant le tour suivant, comme l'exige la fiche du modèle.
Local vs GPU louées vs API : combien coûte Kimi K3 ?
Louer des GPU. L'indice des prix GPU de Flatkey (mis à jour le 24 octobre 2026) affiche des tarifs en temps réel de 7,49 $ par heure-GPU pour la B200, 7,34 $ pour la B300, 3,60 $ pour la H200 et 2,48 $ pour la H100. Un nœud 8x B200 coûte donc environ 59,92 $ de l'heure, soit environ 43 700 $ par mois en fonctionnement 24 h/24 (notre estimation : 8 x 7,49 $ x 730 heures).
API hébergée. La plateforme officielle de Moonshot affiche Kimi K3 à 3,00 $ par million de tokens en entrée, 0,30 $ pour l'entrée en cache et 15,00 $ par million de tokens en sortie. Sur la page du modèle chez Flatkey, Kimi K3 coûte 1,80 $ en entrée, 0,18 $ en entrée en cache et 9,00 $ en sortie par million de tokens, avec le même contexte de 1 048 576 tokens (tous deux consultés le 24 octobre 2026).
Seuil de rentabilité (estimation). Avec un ratio entrée/sortie de 3:1, le tarif de Flatkey revient à environ 3,60 $ par million de tokens combinés. 43 700 $ par mois permettent d'acheter environ 12 milliards de tokens combinés, soit environ 400 millions de tokens par jour. En dessous de ce volume, une API coûte moins cher qu'un nœud 8x B200 dédié, sans compter le temps d'ingénierie.
| Option | Coût initial | Idéal pour |
|---|---|---|
| GGUF 1 bit en local sur une station avec beaucoup de RAM | Matériel possédé | Expériences sensibles à la confidentialité, travail hors ligne, apprentissage |
| Nœud de 8 GPU loué avec vLLM ou SGLang | Location à l'heure | Maîtrise des données et débit de production, recherche en fine-tuning |
| API hébergée (Moonshot ou Flatkey) | Aucun | La plupart des applications, prototypes et trafic variable |
Vous pouvez appeler le modèle hébergé avec le même code que ci-dessus en changeant la base URL :
import os
from openai import OpenAI
client = OpenAI(base_url="https://router.flatkey.ai/v1", api_key=os.environ["FLATKEY_API_KEY"])
r = client.chat.completions.create(model="kimi-k3",
messages=[{"role": "user", "content": "Summarize the Kimi K3 license in two sentences."}])
print(r.choices[0].message.content)
Pour aller plus loin : notre analyse du coût par million de tokens d'un LLM auto-hébergé, la comparaison cloud GPU vs API de modèles et le guide d'accès à l'API Kimi K3.
Dépannage
| Problème | Cause probable | Solution |
|---|---|---|
| Génération extrêmement lente | Le modèle ne tient pas en RAM + VRAM et est lu depuis le disque | Utilisez une quantification plus petite, ajoutez de la RAM ou passez à un serveur GPU |
out of memory au démarrage de llama-server |
Cache KV trop volumineux | Réduisez --ctx-size |
| Entrée image ignorée | Fichier projecteur manquant ou build llama.cpp upstream | Passez --mmproj et compilez le fork d'Unsloth |
| L'image vLLM ne démarre pas | CUDA ou pilote trop ancien | Utilisez CUDA 13 avec le pilote r580 ou ultérieur |
| Appels d'outils cassés | Sortie d'appel d'outil parfois mal formée | Validez les arguments et réessayez |
| Le deuxième tour se comporte bizarrement | Le contenu de réflexion n'est pas renvoyé | Incluez reasoning_content dans l'historique |
| Le téléchargement se bloque | Gros transfert multi-fichiers | Relancez hf download ; il reprend |
FAQ
Kimi K3 peut-il tourner en local ?
Oui. Les poids sont publics, et le plus petit GGUF 1 bit demande environ 610 Go de RAM et de VRAM combinées pour tourner à une vitesse raisonnable. Avec moins de mémoire, il fonctionne quand même, mais lentement, car llama.cpp lit les poids depuis le disque.
Puis-je exécuter Kimi sur un PC gaming ?
Pas de manière utile. Un seul GPU de 24 Go avec 64-128 Go de RAM est très loin des quelque 610 Go nécessaires à la plus petite quantification, vous dépendriez donc du déchargement sur disque. Utilisez plutôt une API ou louez un serveur GPU.
De combien de VRAM Kimi K3 a-t-il besoin ?
Pour les poids natifs, la recette officielle vLLM demande au moins 8x GPU GB300. Pour le GGUF, c'est la somme RAM + VRAM qui compte : environ 610 Go pour le 1 bit et environ 880 Go pour le 2 bits (Unsloth, octobre 2026).
Kimi K3 est-il vraiment moins cher que les autres modèles ?
Via l'API, il se situe en milieu de gamme : 3 $ / 15 $ par million de tokens sur la plateforme de Moonshot et 1,80 $ / 9 $ chez Flatkey en octobre 2026. L'auto-hébergement ne bat le prix de l'API qu'à des volumes très élevés et constants.
Kimi K3 est-il open source ?
Les poids sont ouverts sous la Kimi K3 License, une licence MIT modifiée avec des conditions d'attribution et d'usage commercial à grande échelle.
Puis-je exécuter Kimi K3.1 Pro en local ?
Non. Au 24 octobre 2026, Kimi K3.1 Pro est proposé via l'API de Moonshot, et Kimi K3 est le modèle le plus récent dont les poids sont sur Hugging Face.
Sources
- Fiche du modèle et licence Kimi K3 (octobre 2026)
- Guide Kimi K3 d'Unsloth et fichiers Kimi-K3-GGUF (octobre 2026)
- Recette vLLM pour Kimi K3 (octobre 2026)
- Cookbook SGLang pour Kimi K3 (octobre 2026)
- Tarifs de la plateforme API Kimi (octobre 2026)
- Indice des prix GPU de Flatkey (mis à jour le 24 octobre 2026)
