> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/tutorials/kimi-k2-thinking-how-to-run-locally.md).

# Kimi K2 Thinking: Leitfaden zum lokalen Ausführen

Leitfaden zum Ausführen von Kimi-K2-Thinking und Kimi-K2 auf deinem eigenen lokalen Gerät!

{% hint style="success" %}
Kimi-K2-Thinking wurde veröffentlicht. Lies unseren [Thinking-Leitfaden](#kimi-k2-thinking-guide) oder greife auf [GGUFs hier](https://huggingface.co/unsloth/Kimi-K2-Thinking-GGUF).

Wir haben außerdem mit dem Kimi-Team an [**einem Fix des System-Prompts**](#tokenizer-quirks-and-bug-fixes) für Kimi-K2-Thinking.
{% endhint %}

Kimi-K2 und **Kimi-K2-Thinking** erreichen SOTA-Performance in Wissen, Schlussfolgern, Coding und agentischen Aufgaben. Die vollständigen 1T-Parameter-Modelle von Moonshot AI benötigen 1,09 TB Festplattenspeicher, während die quantisierte **Unsloth Dynamic 1,8-Bit** Version dies auf nur 230 GB (-80 % Größe) reduziert**:** [**Kimi-K2-GGUF**](https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF)

Du kannst jetzt auch unsere [**Kimi-K2-Thinking** GGUFs](https://huggingface.co/unsloth/Kimi-K2-Thinking-GGUF).

Alle Uploads verwenden Unsloth [Dynamic 2.0](/docs/de/grundlagen/dynamic-3.0-ggufs.md) für SOTA [Aider Polyglot](/docs/de/grundlagen/dynamic-3.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md) und 5-Shot-MMLU-Performance. Sieh dir an, wie unsere Dynamic-1–2-Bit-GGUFs bei [Coding-Benchmarks hier abschneiden](/docs/de/grundlagen/dynamic-3.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md).

<a href="#kimi-k2-thinking-guide" class="button primary">Thinking ausführen</a><a href="#kimi-k2-instruct-guide" class="button primary">Instruct ausführen</a>

### :gear: Empfohlene Anforderungen

{% hint style="info" %}
Du benötigst **247 GB Festplattenspeicher** um die 1-Bit-Quantisierung auszuführen!

Die einzige Voraussetzung ist **`Festplattenspeicher + RAM + VRAM ≥ 247 GB`**. Das bedeutet, dass du nicht so viel RAM oder VRAM (GPU) haben musst, um das Modell auszuführen, aber es wird deutlich langsamer sein.
{% endhint %}

Die 1,8-Bit-(UD-TQ1\_0)-Quantisierung passt in eine 24-GB-GPU (wobei alle MoE-Schichten in den Systemspeicher oder auf eine schnelle Festplatte ausgelagert werden). Mit diesem Setup kannst du etwa \~1–2 Token/s erwarten, wenn du außerdem 256 GB zusätzlichen RAM hast. Die vollständige Kimi-K2-Q8-Quantisierung ist 1,09 TB groß und benötigt mindestens 8 x H200-GPUs.

Für optimale Leistung benötigst du mindestens **247 GB Unified Memory oder 247 GB kombinierten RAM+VRAM** für 5+ Token/s. Wenn du weniger als 247 GB kombinierten RAM+VRAM hast, wird die Geschwindigkeit des Modells definitiv leiden.

**Wenn du keine 247 GB RAM+VRAM hast, kein Problem!** llama.cpp verfügt von Haus aus über **Festplatten-Offloading**, sodass es per mmaping weiterhin funktioniert, nur eben langsamer - zum Beispiel konntest du vorher vielleicht 5 bis 10 Token/Sekunde erreichen, jetzt sind es weniger als 1 Token.

Wir empfehlen die Verwendung unserer **UD-Q2\_K\_XL (360 GB)** Quantisierung, um Größe und Genauigkeit auszubalancieren!

{% hint style="success" %}
Für die beste Leistung sollte dein kombinierter VRAM + RAM der Größe der Quantisierung entsprechen, die du herunterlädst. Andernfalls funktioniert es weiterhin über Festplatten-Offloading, nur eben langsamer!
{% endhint %}

## 💭Kimi-K2-Thinking-Leitfaden

Kimi-K2-Thinking sollte im Allgemeinen denselben Anweisungen wie das Instruct-Modell folgen, mit einigen wichtigen Unterschieden, insbesondere in Bereichen wie den Einstellungen und der Chat-Vorlage.

{% hint style="success" %}
**Um das Modell mit voller Präzision auszuführen, musst du nur die 4-Bit- oder 5-Bit-Dynamic-GGUFs verwenden (z. B. UD\_Q4\_K\_XL), da das Modell ursprünglich im INT4-Format veröffentlicht wurde.**

Du kannst zur Sicherheit eine Quantisierung mit höherer Bitzahl wählen, falls es kleine Quantisierungsunterschiede gibt, aber in den meisten Fällen ist das unnötig.
{% endhint %}

### 🌙 Offizielle empfohlene Einstellungen:

Laut [Moonshot AI](https://huggingface.co/moonshotai/Kimi-K2-Thinking), dies sind die empfohlenen Einstellungen für die Inferenz von Kimi-K2-Thinking:

* Stellen Sie <mark style="background-color:green;">**Temperatur 1,0**</mark> ein, um Wiederholungen und Inkohärenz zu reduzieren.
* Empfohlene Kontextlänge = 98.304 (bis zu 256K)
* Hinweis: Die Verwendung unterschiedlicher Tools kann unterschiedliche Einstellungen erfordern

{% hint style="info" %}
Wir empfehlen, den Wert zu setzen <mark style="background-color:green;">**min\_p auf 0,01**</mark> um das Auftreten unwahrscheinlicher Tokens mit niedrigen Wahrscheinlichkeiten zu unterdrücken.
{% endhint %}

Zum Beispiel, wenn wir eine Nutzernachricht "Was ist 1+1?" haben, erhalten wir:

{% code overflow="wrap" %}

```
<|im_system|>system<|im_middle|>Du bist Kimi, ein von Moonshot AI erstellter KI-Assistent.<|im_end|><|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|><|im_assistant|>assistant<|im_middle|>
```

{% endcode %}

### ✨ Kimi K2 Thinking in llama.cpp ausführen

{% hint style="success" %}
Du kannst jetzt das neueste Update von [llama.cpp](https://github.com/ggml-org/llama.cpp) verwenden, um das Modell auszuführen:
{% endhint %}

1. Holen Sie sich die neueste `llama.cpp` auf [hier auf GitHub](https://github.com/ggml-org/llama.cpp). Sie können auch die folgenden Build-Anweisungen befolgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. **Für Apple-Mac-/Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie dann wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert.

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cli
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. Wenn Sie `llama.cpp` um Modelle direkt zu laden, kannst du Folgendes tun: (:UD-TQ1\_0) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Das ist ähnlich wie `ollama run` . Verwenden Sie `export LLAMA_CACHE="folder"` um zu erzwingen `llama.cpp` um an einem bestimmten Speicherort zu speichern.

```bash
export LLAMA_CACHE="unsloth/Kimi-K2-Thinking-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Kimi-K2-Thinking-GGUF:UD-TQ1_0 \
    --n-gpu-layers 99 \\
    --temp 1.0 \\
    --min-p 0.01 \\
    --ctx-size 16384 \\
    --seed 3407 \\
    -ot ".ffn_.*_exps.=CPU"
```

3. Der obige Befehl verwendet etwa 8 GB GPU-Speicher. Wenn du ungefähr 360 GB kombinierten GPU-Speicher hast, entferne `-ot ".ffn_.*_exps.=CPU"` um maximale Geschwindigkeit zu erreichen!

{% hint style="info" %}
Bitte probieren Sie `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Layer auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie `-ot ".ffn_(up|down)_exps.=CPU"` Dadurch werden Up- und Down-Projektions-MoE-Layer ausgelagert.

Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dadurch werden nur Up-Projektions-MoE-Layer ausgelagert.

Und schließlich alle Layer auslagern über `-ot ".ffn_.*_exps.=CPU"` Dies verwendet am wenigsten VRAM.

Sie können den Regex auch anpassen, zum Beispiel `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` bedeutet, Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab dem 6. Layer aufwärts.
{% endhint %}

3. Lade das Modell über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Wir empfehlen, unsere dynamische 2-Bit-Quantisierung UD-Q2\_K\_XL zu verwenden, um Größe und Genauigkeit auszubalancieren. Alle Versionen unter: [huggingface.co/unsloth/Kimi-K2-Thinking-GGUF](https://huggingface.co/unsloth/Kimi-K2-Thinking-GGUF)

{% code overflow="wrap" %}

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal zu Rate-Limits führen, daher auf 0 setzen, um zu deaktivieren
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/Kimi-K2-Thinking-GGUF",
    local_dir = "unsloth/Kimi-K2-Thinking-GGUF",
    allow_patterns = ["*UD-TQ1_0*"], # Verwende "*UD-Q2_K_XL*" für dynamische 2-Bit (381GB)
)
```

{% endcode %}

{% hint style="info" %}
Wenn du feststellst, dass Downloads bei etwa 90 bis 95 % hängen bleiben, sieh bitte unter <https://docs.unsloth.ai/basics/troubleshooting-and-faqs#downloading-gets-stuck-at-90-to-95>
{% endhint %}

4. Führe einen beliebigen Prompt aus.
5. Bearbeiten `--threads -1` für die Anzahl der CPU-Threads (standardmäßig ist dies auf die maximale Anzahl an CPU-Threads gesetzt), `--ctx-size 16384` für die Kontextlänge, `--n-gpu-layers 99` für das GPU-Offloading, auf wie viele Layer. Setze es auf 99 in Kombination mit MoE-CPU-Offloading, um die beste Leistung zu erzielen. Versuche, den Wert anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne es auch, wenn du nur CPU-Inferenz hast.

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \\
    --model unsloth/Kimi-K2-Thinking-GGUF/UD-TQ1_0/Kimi-K2-Thinking-UD-TQ1_0-00001-of-00006.gguf \
    --n-gpu-layers 99 \\
    --temp 1.0 \\
    --min-p 0.01 \\
    --ctx-size 16384 \\
    --seed 3407 \\
    -ot ".ffn_.*_exps.=CPU"
```

{% endcode %}

### :thinking:**Keine Thinking-Tags?**

Vielleicht fällt dir auf, dass es keine *Denken* Tags gibt, wenn du das Modell ausführst. Das ist normales und beabsichtigtes Verhalten.

In deinem `llama.cpp` Script solltest du sicherstellen, dass du das `--special` Flag ganz am Ende deines Befehls angibst. Sobald du das tust, wirst du das `<think>` Token wie erwartet erscheinen sehen.

Du könntest auch sehen, dass jede Antwort mit `<|im_end|>`. Das ist normal, da `<|im_end|>` es ein spezielles Token ist, das beim Ausgeben spezieller Tokens erscheint. Wenn du es ausblenden möchtest, kannst du `<|im_end|>` es als Stopp-String in deinen Einstellungen setzen.

### ✨ Bereitstellen mit llama-server und der Completion-Bibliothek von OpenAI

Nachdem du llama.cpp gemäß [#run-kimi-k2-thinking-in-llama.cpp](#run-kimi-k2-thinking-in-llama.cpp "mention"), kannst du Folgendes verwenden, um einen OpenAI-kompatiblen Server zu starten:

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-server \\
    --model unsloth/Kimi-K2-Thinking-GGUF/UD-TQ1_0/Kimi-K2-Thinking-UD-TQ1_0-00001-of-00006.gguf \
    --alias "unsloth/Kimi-K2-Thinking" \
    -fa on \
    --n-gpu-layers 999 \\
    -ot ".ffn_.*_exps.=CPU" \\
    --min-p 0.01 \\
    --ctx-size 16384 \\
    --port 8001 \
    --jinja
```

{% endcode %}

Verwenden Sie dann die Python-Bibliothek von OpenAI `pip install openai` :

```python
from openai import OpenAI
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Kimi-K2-Thinking",
    messages = [{"role": "user", "content": "Was ist 2+2?"},],
)
print(completion.choices[0].message.content)
```

## :mag:Eigenheiten des Tokenizers und Fehlerbehebungen

**7. November 2025: Wir haben das Kimi-Team benachrichtigt und den Standard-System-Prompt von** `Du bist Kimi, ein von Moonshot AI erstellter KI-Assistent.` **erscheint nicht beim ersten User-Prompt!** Siehe <https://huggingface.co/moonshotai/Kimi-K2-Thinking/discussions/12>

Ein riesiges Dankeschön an das Moonshot-Kimi-Team für ihre extrem schnelle Reaktionszeit auf unsere Anfragen und dafür, das Problem so schnell wie möglich behoben zu haben!

**16. Juli 2025: Kimi K2 hat ihren Tokenizer aktualisiert, um mehrere Tool-Aufrufe zu ermöglichen** gemäß <https://x.com/Kimi_Moonshot/status/1945050874067476962>

**18. Juli 2025: Wir haben einen System-Prompt behoben – Kimi hat auch hier über unseren Fix getwittert:** <https://x.com/Kimi_Moonshot/status/1946130043446690030>. Der Fix wurde auch hier beschrieben: <https://huggingface.co/moonshotai/Kimi-K2-Instruct/discussions/28>

Wenn du die alten Checkpoints bereits heruntergeladen hast – kein Problem – lade einfach den ersten GGUF-Split herunter, der geändert wurde. ODER wenn du keine neuen Dateien herunterladen möchtest, mache Folgendes:

```bash
wget https://huggingface.co/unsloth/Kimi-K2-Instruct/raw/main/chat_template.jinja
./llama.cpp ... --chat-template-file /dir/to/chat_template.jinja
```

Der Kimi-K2-Tokenizer war interessant zum Herumspielen – <mark style="background-color:green;">**in seiner Funktionsweise ist er größtenteils ähnlich wie der Tokenizer von GPT-4o**</mark>! Zunächst sehen wir in der [tokenization\_kimi.py](https://huggingface.co/moonshotai/Kimi-K2-Instruct/blob/main/tokenization_kimi.py) Datei den folgenden regulären Ausdruck (Regex), den Kimi K2 verwendet:

```python
pat_str = "|".join(
    [
        r"""[\p{Han}]+""",
        r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]*[\p{Ll}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?""",
        r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]+[\p{Ll}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?""",
        r"""\p{N}{1,3}""",
        r""" ?[^\s\p{L}\p{N}]+[\r\n]*""",
        r"""\s*[\r\n]+""",
        r"""\s+(?!\S)""",
        r"""\s+""",
    ]
)
```

Nach sorgfältiger Prüfung stellen wir fest, dass Kimi K2 dem Regex des Tokenizers von GPT-4o nahezu identisch ist, [der im Quellcode von llama.cpp zu finden ist](https://github.com/ggml-org/llama.cpp/blob/55c509daf51d25bfaee9c8b8ce6abff103d4473b/src/llama-vocab.cpp#L400).

{% code overflow="wrap" %}

```
[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?|[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]+[\p{Ll}\p{Lm}\p{Lo}\p{M}]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n/]*|\s*[\r\n]+|\s+(?!\S)|\s+
```

{% endcode %}

Beide tokenisieren Zahlen in Gruppen von 1 bis 3 Ziffern (9, 99, 999) und verwenden ähnliche Muster. Der einzige Unterschied scheint die Behandlung von "Han"- oder chinesischen Zeichen zu sein, mit denen der Tokenizer von Kimi besser zurechtkommt. [Der PR](https://github.com/ggml-org/llama.cpp/pull/14654) von <https://github.com/gabriellarson> geht mit diesen Unterschieden nach einigen [Diskussionen hier gut um](https://github.com/ggml-org/llama.cpp/issues/14642#issuecomment-3067324745).

<mark style="background-color:green;">**Wir stellen außerdem fest, dass das korrekte EOS-Token nicht \[EOS] sein sollte, sondern <|im\_end|>, was wir auch in unseren Modellkonvertierungen behoben haben.**</mark>

## 🌝Kimi-K2-Instruct-Leitfaden

Schritt-für-Schritt-Anleitung zum Ausführen der Instruct-Kimi-K2-Modelle einschließlich Kimi K2 0905 - dem Update vom 5. September.

### 🌙 Offizielle empfohlene Einstellungen:

Laut [Moonshot AI](https://huggingface.co/moonshotai/Kimi-K2-Instruct), dies sind die empfohlenen Einstellungen für die Inferenz von Kimi K2:

* Stellen Sie <mark style="background-color:green;">**Temperatur 0,6**</mark> ein, um Wiederholungen und Inkohärenz zu reduzieren.
* Der ursprüngliche Standard-System-Prompt lautet:

  ```
  Du bist ein hilfreicher Assistent
  ```
* (Optional) Moonshot schlägt für den System-Prompt außerdem Folgendes vor:

  ```
  Du bist Kimi, ein von Moonshot AI erstellter KI-Assistent.
  ```

{% hint style="success" %}
Wir empfehlen, den Wert zu setzen <mark style="background-color:green;">**min\_p auf 0,01**</mark> um das Auftreten unwahrscheinlicher Tokens mit niedrigen Wahrscheinlichkeiten zu unterdrücken.
{% endhint %}

### :1234: Chat-Vorlage und Prompt-Format

Kimi Chat verwendet tatsächlich ein BOS-Token (Beginning-of-Sentence-Token). Die Rollen System, User und Assistant werden alle mit `<|im_middle|>` eingeschlossen, was interessant ist, und jede von ihnen erhält ihr jeweiliges Token `<|im_system|>, <|im_user|>, <|im_assistant|>`.

{% code overflow="wrap" %}

```python
<|im_system|>system<|im_middle|>Du bist ein hilfreicher Assistent<|im_end|><|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|><|im_assistant|>assistant<|im_middle|>2<|im_end|>
```

{% endcode %}

Um die Gesprächsgrenzen zu trennen (du musst jede neue Zeile entfernen), erhalten wir:

{% code overflow="wrap" %}

```
<|im_system|>system<|im_middle|>Du bist ein hilfreicher Assistent<|im_end|>
<|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|>
<|im_assistant|>assistant<|im_middle|>2<|im_end|>
```

{% endcode %}

### :floppy\_disk: Modell-Uploads

**ALLE unsere Uploads** - einschließlich derer, die nicht imatrix-basiert oder dynamisch sind, nutzen unseren Kalibrierungsdatensatz, der speziell für dialogische, Coding- und Reasoning-Aufgaben optimiert ist.

<table data-full-width="false"><thead><tr><th>MoE-Bits</th><th>Typ + Link</th><th>Festplattengröße</th><th>Details</th></tr></thead><tbody><tr><td>1,66 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-TQ1_0">UD-TQ1_0</a></td><td><strong>245 GB</strong></td><td>1,92/1,56 Bit</td></tr><tr><td>1,78 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ1_S">UD-IQ1_S</a></td><td><strong>281 GB</strong></td><td>2,06/1,56 Bit</td></tr><tr><td>1,93 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ1_M">UD-IQ1_M</a></td><td><strong>304 GB</strong></td><td>2.5/2.06/1.56</td></tr><tr><td>2,42 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ2_XXS">UD-IQ2_XXS</a></td><td><strong>343 GB</strong></td><td>2,5/2,06 Bit</td></tr><tr><td>2,71 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q2_K_XL">UD-Q2_K_XL</a></td><td><strong>381 GB</strong></td><td>3,5/2,5 Bit</td></tr><tr><td>3,12 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ3_XXS">UD-IQ3_XXS</a></td><td><strong>417 GB</strong></td><td>3,5/2,06 Bit</td></tr><tr><td>3,5 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q3_K_XL">UD-Q3_K_XL</a></td><td><strong>452 GB</strong></td><td>4,5/3,5 Bit</td></tr><tr><td>4,5 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q4_K_XL">UD-Q4_K_XL</a></td><td><strong>588 GB</strong></td><td>5,5/4,5 Bit</td></tr><tr><td>5,5 Bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q5_K_XL">UD-Q5_K_XL</a></td><td><strong>732 GB</strong></td><td>6,5/5,5 Bit</td></tr></tbody></table>

Wir haben auch Versionen in [BF16-Format](https://huggingface.co/unsloth/Kimi-K2-Instruct-BF16).

### ✨ Instruct in llama.cpp ausführen

1. Holen Sie sich die neueste `llama.cpp` auf [hier auf GitHub](https://github.com/ggml-org/llama.cpp). Sie können auch die folgenden Build-Anweisungen befolgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten.

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cli
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. Wenn Sie `llama.cpp` um Modelle direkt zu laden, kannst du Folgendes tun: (:UD-IQ1\_S) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Das ist ähnlich wie `ollama run` . Verwenden Sie `export LLAMA_CACHE="folder"` um zu erzwingen `llama.cpp` um an einem bestimmten Speicherort zu speichern.\ <mark style="background-color:green;">**Um das neue Update vom September 2025 für das Modell auszuführen, ändere den Modellnamen von 'Kimi-K2-Instruct' zu 'Kimi-K2-Instruct-0905'.**</mark>

{% hint style="info" %}
Bitte probieren Sie `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Layer auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie `-ot ".ffn_(up|down)_exps.=CPU"` Dadurch werden Up- und Down-Projektions-MoE-Layer ausgelagert.

Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dadurch werden nur Up-Projektions-MoE-Layer ausgelagert.

Und schließlich alle Layer auslagern über `-ot ".ffn_.*_exps.=CPU"` Dies verwendet am wenigsten VRAM.

Sie können den Regex auch anpassen, zum Beispiel `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` bedeutet, Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab dem 6. Layer aufwärts.
{% endhint %}

```bash
export LLAMA_CACHE="unsloth/Kimi-K2-Instruct-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Kimi-K2-Instruct-GGUF:TQ1_0 \
    --n-gpu-layers 99 \\
    --temp 0.6 \
    --min-p 0.01 \\
    --ctx-size 16384 \\
    --seed 3407 \\
    -ot ".ffn_.*_exps.=CPU"
```

3. Lade das Modell über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Sie können `UD-TQ1_0`(dynamische 1,8-Bit-Quantisierung) oder andere quantisierte Versionen wie `Q2_K_XL` . Wir <mark style="background-color:green;">**empfehlen, unsere dynamische 2-Bit-Quantisierung zu verwenden**</mark><mark style="background-color:green;">**&#x20;**</mark><mark style="background-color:green;">**`UD-Q2_K_XL`**</mark><mark style="background-color:green;">**&#x20;**</mark><mark style="background-color:green;">**zu verwenden, um Größe und Genauigkeit auszubalancieren**</mark>. Weitere Versionen unter: [huggingface.co/unsloth/Kimi-K2-Instruct-GGUF](https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF)

{% code overflow="wrap" %}

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal zu Rate-Limits führen, daher auf 0 setzen, um zu deaktivieren
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*"], # Dynamische 1-Bit (281GB) Verwende "*UD-Q2_K_XL*" für dynamische 2-Bit (381GB)
)
```

{% endcode %}

{% hint style="info" %}
Wenn du feststellst, dass Downloads bei etwa 90 bis 95 % hängen bleiben, sieh bitte unter <https://docs.unsloth.ai/basics/troubleshooting-and-faqs#downloading-gets-stuck-at-90-to-95>
{% endhint %}

4. Führe einen beliebigen Prompt aus.
5. Bearbeiten `--threads -1` für die Anzahl der CPU-Threads (standardmäßig ist dies auf die maximale Anzahl an CPU-Threads gesetzt), `--ctx-size 16384` für die Kontextlänge, `--n-gpu-layers 99` für das GPU-Offloading, auf wie viele Layer. Setze es auf 99 in Kombination mit MoE-CPU-Offloading, um die beste Leistung zu erzielen. Versuche, den Wert anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne es auch, wenn du nur CPU-Inferenz hast.

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \\
    --model unsloth/Kimi-K2-Instruct-GGUF/UD-TQ1_0/Kimi-K2-Instruct-UD-TQ1_0-00001-of-00005.gguf \
    --n-gpu-layers 99 \\
    --temp 0.6 \
    --min-p 0.01 \\
    --ctx-size 16384 \\
    --seed 3407 \\
    -ot ".ffn_.*_exps.=CPU"
```

{% endcode %}

### :bird: Flappy Bird + andere Tests <a href="#heptagon-test" id="heptagon-test"></a>

Wir haben den Flappy-Bird-Test eingeführt, als uns unsere 1,58-Bit-Quantisierungen für DeepSeek R1 bereitgestellt wurden. Wir stellten fest, dass Kimi K2 eines der wenigen Modelle war, das alle unsere Aufgaben, einschließlich dieser hier, auf Anhieb löste, [Heptagon ](/docs/de/modelle/tutorials/deepseek-r1-0528-how-to-run-locally.md#heptagon-test)und andere Tests sogar bei 2-Bit. Das Ziel ist, das LLM zu bitten, ein Flappy-Bird-Spiel zu erstellen, dabei aber einigen spezifischen Anweisungen zu folgen:

{% code overflow="wrap" %}

```
Erstelle ein Flappy-Bird-Spiel in Python. Du musst die folgenden Dinge einbauen:
1. Sie müssen pygame verwenden.
2. Die Hintergrundfarbe sollte zufällig gewählt werden und hell sein. Beginnen Sie mit einer hellblauen Farbe.
3. Wenn die LEERTASTE mehrmals gedrückt wird, beschleunigt sich der Vogel.
4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als dunkle Farbe gewählt werden.
5. Platzieren Sie unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.
6. Zeigen Sie oben rechts einen Punktestand an. Erhöhen Sie ihn, wenn Sie Rohre passieren und sie nicht berühren.
7. Erstellen Sie zufällig verteilte Rohre mit genügend Abstand. Färben Sie sie zufällig dunkelgrün, hellbraun oder in einem dunklen Grauton.
8. Wenn Sie verlieren, zeigen Sie den Bestwert an. Platzieren Sie den Text innerhalb des Bildschirms. Mit q oder Esc wird das Spiel beendet. Ein Neustart erfolgt durch erneutes Drücken von LEERTASTE.
Das fertige Spiel sollte in einem Markdown-Abschnitt in Python stehen. Prüfe deinen Code auf Fehler und behebe sie vor dem finalen Markdown-Abschnitt.
```

{% endcode %}

Du kannst die dynamischen Quantisierungen auch mithilfe des Heptagon-Tests testen, gemäß [r/Localllama](https://www.reddit.com/r/LocalLLaMA/comments/1j7r47l/i_just_made_an_animation_of_a_ball_bouncing/) das das Modell darauf testet, eine einfache Physik-Engine zu erstellen, um Bälle zu simulieren, die in einer sich bewegenden, geschlossenen Heptagonform rotieren.

<figure><img src="https://docs.unsloth.ai/~gitbook/image?url=https%3A%2F%2F3215535692-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FxhOjnexMCB3dmuQFQ2Zq%252Fuploads%252F2O72oTw5yPUbcxXjDNKS%252Fsnapshot.jpg%3Falt%3Dmedia%26token%3Dce852f9f-20ee-4b93-9d7b-1a5f211b9e04&#x26;width=768&#x26;dpr=4&#x26;quality=100&#x26;sign=55d1134d&#x26;sv=2" alt="" width="563"><figcaption></figcaption></figure>

Das Ziel ist, das Heptagon rotieren zu lassen, und die Bälle im Heptagon sollten sich bewegen. Der Prompt ist unten:

{% code overflow="wrap" %}

```
Schreibe ein Python-Programm, das 20 Bälle zeigt, die in einem rotierenden Heptagon umherspringen:\n- Alle Bälle haben denselben Radius.\n- Alle Bälle haben eine Nummer von 1 bis 20.\n- Alle Bälle fallen beim Start aus dem Zentrum des Heptagons heraus.\n- Die Farben sind: #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35\n- Die Bälle sollen von Gravitation und Reibung beeinflusst werden, und sie müssen realistisch von den rotierenden Wänden abprallen. Außerdem soll es Kollisionen zwischen den Bällen geben.\n- Das Material aller Bälle bestimmt, dass ihre Aufprall-Höhe den Radius des Heptagons nicht überschreitet, aber höher als der Ballradius sein muss.\n- Alle Bälle rotieren mit Reibung, die Zahlen auf den Bällen können verwendet werden, um den Spin des Balls anzuzeigen.\n- Das Heptagon rotiert um sein Zentrum, und die Rotationsgeschwindigkeit beträgt 360 Grad pro 5 Sekunden.\n- Die Heptagon-Größe sollte groß genug sein, um alle Bälle zu enthalten.\n- Verwende nicht die pygame-Bibliothek; implementiere Kollisionserkennung und Kollisionsreaktion usw. selbst. Folgende Python-Bibliotheken sind erlaubt: tkinter, math, numpy, dataclasses, typing, sys.\n- Der gesamte Code soll in einer einzigen Python-Datei stehen.
```

{% endcode %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/de/modelle/tutorials/kimi-k2-thinking-how-to-run-locally.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.