Kosten, Abrechnung und Betrieb24. Oktober 2026Flatkey Team

Kann man Kimi K3 lokal ausführen? Leitfaden zu Hardware, GGUF und vLLM (2026)

Kimi K3 läuft lokal, aber selbst das kleinste 1-Bit-GGUF braucht rund 610 GB RAM plus VRAM. Genaue Hardwareanforderungen, llama.cpp- und vLLM-Befehle, Lizenzbedingungen und ein Kostenvergleich mit Miet-GPUs und APIs.

Kann man Kimi K3 lokal ausführen? Leitfaden zu Hardware, GGUF und vLLM (2026)

Ja, Kimi K3 lässt sich lokal ausführen, weil Moonshot AI die Gewichte auf Hugging Face veröffentlicht. Es handelt sich aber um ein Modell mit 2,8 Billionen Parametern, „lokal“ bedeutet also rund 610 GB RAM und VRAM zusammen für das kleinste 1-Bit-GGUF oder einen kompletten Blackwell-Knoten mit 8 GPUs für die nativen Gewichte. Auf einer einzelnen Workstation mit weniger Speicher lädt das Modell trotzdem von der Festplatte, nur sehr langsam. Für die meisten Entwickler ist es günstiger, K3 auf gemieteten GPUs zu betreiben oder über eine API aufzurufen, als Hardware zu kaufen.

Dieser Leitfaden zeigt, was Sie mit Stand 24. Oktober 2026 brauchen, um Kimi K3 auf eigenen Rechnern zu betreiben: die Lizenz, den genauen Speicherbedarf je Quantisierung, Schritt-für-Schritt-Befehle für llama.cpp und vLLM, den Aufruf Ihres lokalen Servers aus Code und einen Kostenvergleich mit Miet-GPUs und gehosteten APIs. Die Zahlen stammen aus der Model Card von Moonshot AI, den offiziellen Rezepten von vLLM und SGLang und der Dokumentation von Unsloth; alles, was wir geschätzt haben, ist als Schätzung gekennzeichnet.

Kimi K3 im Überblick

Merkmal	Wert
Entwickler	Moonshot AI
Gewichte	moonshotai/Kimi-K3 auf Hugging Face
Architektur	Mixture of Experts: 2,8T Parameter insgesamt, 104B aktiv pro Token
Experten	896 geroutete Experten, 16 pro Token ausgewählt, plus 2 geteilte
Schichten	93 (69 KDA-Schichten mit linearer Attention und 24 Gated-MLA-Schichten)
Kontextfenster	1.048.576 Tokens
Eingaben	Text und Bilder (Vision-Encoder MoonViT-V2, 401M Parameter)
Native Präzision	MXFP4-Gewichte mit MXFP8-Aktivierungen (quantisierungsbewusstes Training)
Reasoning	Denken immer aktiv; `reasoning_effort` low, high oder max (Standard max)
Lizenz	Kimi K3 License (modifizierte MIT-Lizenz)

Quelle: die Model Card von Kimi K3, abgerufen am 24. Oktober 2026.

Zwei Hinweise vorab. Erstens bietet Moonshot AI über seine API inzwischen Kimi K3.1 Pro an und bezeichnet K3 als „Flaggschiff der vorherigen Generation“; mit Stand 24. Oktober 2026 sind die neuesten offenen Gewichte auf Hugging Face aber weiterhin die von Kimi K3, also ist K3 das Modell, das Sie selbst betreiben können. Zweitens arbeitet K3 ausschließlich im Denkmodus: Ihr Client muss in mehrstufigen Gesprächen reasoning_content und Tool-Aufrufe zurückgeben, wie in der Model Card beschrieben.

Darf man Kimi K3 kommerziell nutzen?

Die Kimi K3 License ist laut Lizenzdatei auf Hugging Face (Oktober 2026) eine MIT-artige Lizenz mit zwei zusätzlichen Bedingungen:

Wenn Sie K3 als Model-as-a-Service-Geschäft mit mehr als 20 Millionen US-Dollar Umsatz in den vorangegangenen 12 Monaten anbieten, benötigen Sie eine gesonderte Vereinbarung mit Moonshot AI.
Wenn Ihr Produkt mehr als 100 Millionen monatlich aktive Nutzer oder mehr als 20 Millionen US-Dollar Monatsumsatz hat, müssen Sie „Kimi K3“ in der Benutzeroberfläche anzeigen.

Die interne Nutzung im Unternehmen wird durch diese Bedingungen nicht eingeschränkt. Für die meisten Startups und Teams ist die lokale oder selbst gehostete Nutzung erlaubt; lesen Sie vor dem Livegang den vollständigen Lizenztext.

Wie viel Hardware braucht Kimi K3?

GGUF-Quantisierungen (llama.cpp)

Unsloth veröffentlicht dynamische GGUF-Quantisierungen. Die Faustregel: RAM plus VRAM sollten mindestens der Größe der Quantisierung entsprechen, sonst wird das Modell auf die Festplatte ausgelagert und läuft deutlich langsamer.

Quantisierung	Benötigter Speicher (RAM + VRAM)	Hinweise
Dynamisch 1-Bit S (`UD-IQ1_S`)	etwa 610 GB	594 GB Dateien; von Unsloth empfohlener Kompromiss aus Größe und Qualität, etwa 79 % Top-1-Genauigkeit
Dynamisch 1-Bit M	etwa 665 GB
Dynamisch 2-Bit XXS	etwa 726 GB
Dynamisch 2-Bit XL	etwa 880 GB	Unsloth meldet etwa 90 % Genauigkeit für sein dynamisches 2-Bit mit 861 GB
Q8 (`UD-Q8_K_XL`, verlustfrei)	etwa 1,6 TB	1,56 TB Dateien; entspricht den nativen MXFP4-Gewichten

Unsloth meldet etwa 20 Tokens pro Sekunde bei der Generierung, wenn die 1-Bit-Quantisierung auf B200-GPUs passt. Auf CPU-lastigen Rechnern, die den Großteil der Gewichte im System-RAM halten, sind deutlich niedrigere Geschwindigkeiten zu erwarten; wir haben sie nicht gemessen, betrachten Sie daher jede Zahl als Schätzung, bis Sie Ihre eigene Hardware getestet haben.

Was bedeutet das in der Praxis? Einige realistische lokale Setups:

Setup	Passt 1-Bit (610 GB)?	Erwartung (Schätzung)
Gaming-PC: 1x RTX 4090 (24 GB) + 128 GB RAM	Nein	Läuft nur mit starker Auslagerung auf die Festplatte; sehr langsam, nur für Tests geeignet
Workstation oder Server: 1-2 GPUs + 768 GB DDR5	Ja	Brauchbar für Einzelnutzer-Experimente bei niedriger Geschwindigkeit
Multi-GPU-Server mit 8x GPUs à 80-141 GB	Ja, im VRAM	Interaktive Geschwindigkeit für einen oder wenige Nutzer
Knoten mit 8x B300 / GB300-Klasse	Native MXFP4-Gewichte	Produktivbetrieb mit vLLM oder SGLang

Native Gewichte (vLLM und SGLang)

Für die offiziellen Gewichte verlangt das vLLM-Rezept für Kimi K3 mindestens 8x GB300-GPUs (oder mindestens 8x MI355X bzw. MI350X unter AMD ROCm) und nutzt das Image vllm/vllm-openai:kimi-k3, das CUDA 13 und den NVIDIA-Treiber r580 oder neuer erfordert. Das SGLang-Cookbook nennt Knotenformen wie B300 1x8, GB300 2x4, B200 2x8, GB200 4x4, H200 2x8, H100 4x8 und MI350X/MI355X 1x8, doch mit Stand Oktober 2026 ist nur die Konfiguration B300 1x8 als verifiziert markiert. Mit anderen Worten: Ein H100-Deployment braucht vier Knoten mit je 8 GPUs, was für fast alle, die „lokal“ arbeiten, unerreichbar ist.

Mehr zur Dimensionierung finden Sie in unserem Leitfaden zum GPU-Speicherbedarf von LLMs und im Leitfaden zum Expert-Parallel-Deployment mit vLLM.

Kimi K3 lokal mit llama.cpp (GGUF) ausführen

Diese Schritte folgen dem Leitfaden von Unsloth. Die Bildunterstützung von K3 erfordert derzeit Unsloths Fork von llama.cpp; für reine Textnutzung gelten dieselben Schritte.

1. llama.cpp kompilieren. Verwenden Sie -DGGML_CUDA=OFF, wenn Sie keine NVIDIA-GPU haben.

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. Die 1-Bit-Quantisierung (etwa 594 GB) und den Vision-Projektor herunterladen. Prüfen Sie vorher den freien Speicherplatz.

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. Im Terminal chatten. Verwenden Sie Moonshots empfohlenes Sampling: temperature 1.0 und top_p 0.95 (top_p 1.0 für agentische Aufgaben).

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. Eine OpenAI-kompatible API bereitstellen. llama-server stellt /v1/chat/completions bereit. Eine kleinere Kontextgröße spart Speicher für den KV-Cache.

./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

Kimi K3 mit vLLM betreiben (ganzer Knoten)

Wenn Sie einen unterstützten 8-GPU-Knoten besitzen oder mieten, bietet vLLM Produktionsdurchsatz, Tool-Aufrufe und den vollen 1M-Kontext. Der Basisbefehl aus dem offiziellen Rezept:

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

Das Rezept weist außerdem darauf hin, dass das Tool-Call-Format gelegentlich fehlerhaft ist; validieren Sie daher die Tool-Argumente und wiederholen Sie die Anfrage, wenn das Parsen fehlschlägt. Unser vLLM-Deployment-Leitfaden und der Leitfaden zur Multi-GPU-Inferenz behandeln Monitoring und Tuning.

Den lokalen Kimi-K3-Server aufrufen

Sowohl llama-server (oben Port 8080) als auch vLLM (Port 8000) sprechen die OpenAI-API, daher funktioniert jedes OpenAI-SDK.

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);

Fügen Sie in mehrstufigen Chats vor der nächsten Runde die Assistant-Nachricht samt reasoning_content und allen tool_calls dem Verlauf hinzu, wie es die Model Card verlangt.

Lokal vs. Miet-GPUs vs. API: Was kostet Kimi K3?

GPUs mieten. Der GPU-Preisindex von Flatkey (aktualisiert am 24. Oktober 2026) nennt Echtzeitpreise von 7,49 $ pro GPU-Stunde für B200, 7,34 $ für B300, 3,60 $ für H200 und 2,48 $ für H100. Ein 8x-B200-Knoten kostet damit etwa 59,92 $ pro Stunde oder rund 43.700 $ pro Monat im Dauerbetrieb (unsere Schätzung: 8 x 7,49 $ x 730 Stunden).

Gehostete API. Moonshots offizielle Plattform listet Kimi K3 mit 3,00 $ pro Million Eingabe-Tokens, 0,30 $ für gecachte Eingaben und 15,00 $ pro Million Ausgabe-Tokens. Auf der Flatkey-Modellseite kostet Kimi K3 1,80 $ für Eingaben, 0,18 $ für gecachte Eingaben und 9,00 $ für Ausgaben pro Million Tokens, bei gleichem Kontext von 1.048.576 Tokens (beide abgerufen am 24. Oktober 2026).

Break-even (Schätzung). Bei einem Verhältnis von Eingabe zu Ausgabe von 3:1 ergibt der Flatkey-Preis etwa 3,60 $ pro Million gemischter Tokens. Für 43.700 $ im Monat bekommt man rund 12 Milliarden gemischte Tokens, also etwa 400 Millionen Tokens pro Tag. Unterhalb dieses Volumens ist eine API günstiger als ein dedizierter 8x-B200-Knoten, noch bevor man die Engineering-Zeit einrechnet.

Option	Anfangskosten	Am besten für
Lokales 1-Bit-GGUF auf einer Workstation mit viel RAM	Eigene Hardware	Datenschutzsensible Experimente, Offline-Arbeit, Lernen
Gemieteter 8-GPU-Knoten mit vLLM oder SGLang	Stundenmiete	Datenkontrolle plus Produktionsdurchsatz, Fine-Tuning-Forschung
Gehostete API (Moonshot oder Flatkey)	Keine	Die meisten Apps, Prototypen und schwankender Traffic

Sie können das gehostete Modell mit demselben Code wie oben aufrufen, indem Sie die Base-URL ändern:

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)

Mehr dazu in unserer Analyse der Kosten pro Million Tokens bei selbst gehosteten LLMs, im Vergleich GPU-Cloud vs. Modell-API und im Leitfaden zum Zugriff auf die Kimi-K3-API.

Fehlerbehebung

Problem	Wahrscheinliche Ursache	Lösung
Generierung extrem langsam	Modell passt nicht in RAM + VRAM und wird von der Festplatte gelesen	Kleinere Quantisierung nutzen, RAM aufrüsten oder auf einen GPU-Server wechseln
`out of memory` beim Start von llama-server	KV-Cache zu groß	`--ctx-size` verringern
Bildeingabe wird ignoriert	Projektordatei fehlt oder Upstream-Build von llama.cpp	`--mmproj` übergeben und Unsloths Fork kompilieren
vLLM-Image startet nicht	CUDA oder Treiber zu alt	CUDA 13 mit Treiber r580 oder neuer verwenden
Fehlerhafte Tool-Aufrufe	Gelegentlich fehlerhafte Tool-Call-Ausgabe	Argumente validieren und erneut versuchen
Zweite Runde verhält sich seltsam	Denkinhalt wurde nicht zurückgegeben	`reasoning_content` in den Verlauf aufnehmen
Download bleibt hängen	Große Übertragung mit vielen Dateien	`hf download` erneut ausführen; der Download wird fortgesetzt

Häufig gestellte Fragen

Kann Kimi K3 lokal laufen?

Ja. Die Gewichte sind öffentlich, und das kleinste 1-Bit-GGUF braucht etwa 610 GB RAM und VRAM zusammen, um mit vernünftiger Geschwindigkeit zu laufen. Mit weniger Speicher läuft es trotzdem, aber langsam, weil llama.cpp die Gewichte von der Festplatte liest.

Kann ich Kimi auf einem Gaming-PC ausführen?

Nicht sinnvoll. Eine einzelne 24-GB-GPU mit 64-128 GB RAM liegt weit unter den rund 610 GB, die die kleinste Quantisierung braucht, Sie wären also auf Festplattenauslagerung angewiesen. Nutzen Sie stattdessen eine API oder mieten Sie einen GPU-Server.

Wie viel VRAM braucht Kimi K3?

Für die nativen Gewichte verlangt das offizielle vLLM-Rezept mindestens 8x GB300-GPUs. Bei GGUF zählt die Summe aus RAM und VRAM: etwa 610 GB für 1-Bit und etwa 880 GB für 2-Bit (Unsloth, Oktober 2026).

Ist Kimi K3 wirklich günstiger als andere Modelle?

Über die API liegt es im mittleren Preissegment: 3 $ / 15 $ pro Million Tokens auf Moonshots Plattform und 1,80 $ / 9 $ bei Flatkey mit Stand Oktober 2026. Self-Hosting schlägt die API-Preise nur bei sehr hohen, gleichmäßigen Volumen.

Ist Kimi K3 Open Source?

Die Gewichte sind unter der Kimi K3 License offen, einer modifizierten MIT-Lizenz mit Bedingungen zur Namensnennung und zur kommerziellen Nutzung in großem Maßstab.