# Kimi K2 Thinking: Anleitung zum lokalen Ausführen

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

Wir haben auch mit dem Kimi-Team zusammengearbeitet an [**System-Prompt-Fix**](#tokenizer-quirks-and-bug-fixes) für Kimi-K2-Thinking.
{% endhint %}

Kimi-K2 und **Kimi-K2-Thinking** erreichen SOTA-Leistung in Wissen, Schlussfolgerung, Kodierung 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 reduziert (-80% Größe)**:** [**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/unsloth-dynamic-2.0-ggufs.md) für SOTA [Aider Polyglot](/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md) und 5-shot MMLU-Leistung ausführen. Sieh, wie unsere Dynamic 1–2 Bit GGUFs bei [Coding-Benchmarks hier](/docs/de/grundlagen/unsloth-dynamic-2.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 das 1bit-Quant auszuführen!

Die einzige Voraussetzung ist **`Festplattenspeicher + RAM + VRAM ≥ 247GB`**. 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 %}

Das 1,8-Bit (UD-TQ1\_0) Quant passt in eine 1x 24GB GPU (mit allen MoE-Schichten ausgelagert in System-RAM oder auf eine schnelle Festplatte). Erwartet etwa \~1–2 Token/s mit dieser Konfiguration, wenn du zusätzlich 256GB RAM hast. Das vollständige Kimi K2 Q8 Quant hat eine Größe von 1,09 TB und benötigt mindestens 8 x H200 GPUs.

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

**Wenn du nicht 247GB RAM+VRAM hast, kein Problem!** llama.cpp hat von Haus aus **Festplatten-Auslagerung**, sodass es durch mmaping trotzdem funktioniert, nur langsamer — zum Beispiel könntest du vorher 5 bis 10 Token/Sekunde bekommen haben, jetzt sind es unter 1 Token.

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

{% hint style="success" %}
Für beste Leistung sollte dein VRAM + RAM zusammen der Größe des heruntergeladenen Quants entsprechen. Wenn nicht, funktioniert es weiterhin über Festplatten-Auslagerung, es wird nur langsamer!
{% endhint %}

## 💭Kimi-K2-Thinking Leitfaden

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

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

Du kannst eine höherbitige Quantisierung wählen, um auf der sicheren Seite zu sein bei kleinen Quantisierungsunterschieden, aber in den meisten Fällen ist das unnötig.
{% endhint %}

### 🌙 Offiziell empfohlene Einstellungen:

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

* Setze das <mark style="background-color:green;">**Temperatur 1.0**</mark> um Wiederholungen und Inkohärenz zu reduzieren.
* Vorgeschlagene Kontextlänge = 98.304 (bis zu 256K)
* Hinweis: Die Verwendung unterschiedlicher Tools kann unterschiedliche Einstellungen erfordern

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

Zum Beispiel erhalten wir bei einer Nutzerfrage "Was ist 1+1?":

{% 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. Hole dir die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Du kannst auch den Build-Anweisungen unten folgen. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn du keine GPU hast oder nur CPU-Inferenz möchtest. **Für Apple Mac / Metal-Geräte**, setze `-DGGML_CUDA=OFF` 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 du `llama.cpp` direkt zum Laden von Modellen 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 `llama.cpp` um an einen bestimmten Ort 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. Obiges wird etwa 8GB GPU-Speicher verwenden. Wenn du etwa 360GB kombinierten GPU-Speicher hast, entferne `-ot ".ffn_.*_exps.=CPU"` um maximale Geschwindigkeit zu erzielen!

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

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert Up- und Down-Projektions-MoE-Schichten aus.

Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur Up-Projektions-MoE-Schichten aus.

Und schließlich lagern Sie alle Schichten über `-ot ".ffn_.*_exps.=CPU"` aus.

Sie können auch den Regex 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-Schichten auszulagern, aber nur ab der 6. Schicht.
{% endhint %}

3. Laden Sie das Modell herunter (nach der Installation `pip install huggingface_hub hf_transfer` ). Wir empfehlen unser 2-Bit Dynamic Quant 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 Ratenbegrenzung verursachen, also 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 Dynamic 2bit (381GB)
)
```

{% endcode %}

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

4. Führe beliebige Prompts aus.
5. Bearbeiten `--threads -1` für die Anzahl der CPU-Threads (standardmäßig ist es auf die maximale Anzahl der CPU-Threads gesetzt), `für die Anzahl der CPU-Threads bearbeiten,` --ctx-size 16384 `--n-gpu-layers 99` für GPU-Auslagerung, auf wie viele Schichten. Setze es auf 99 in Kombination mit MoE-CPU-Auslagerung, um die beste Leistung zu erzielen. Versuche es anzupassen, wenn deine GPU keinen Speicher mehr hat. Entferne es auch, wenn du nur CPU-Inferenz nutzt.

{% 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?**

Du wirst vielleicht bemerken, dass keine *Denken* Tags vorhanden sind, wenn du das Modell ausführst. Das ist normales und beabsichtigtes Verhalten.

In deinem `llama.cpp` Skript, stelle sicher, dass du das `--special` Flag ganz am Ende deines Befehls einschließt. Sobald du das tust, wirst du das `<think>` Token wie erwartet erscheinen sehen.

Möglicherweise siehst du auch, dass jede Antwort mit `<|im_end|>`endet. Das ist normal, da `<|im_end|>` ein spezielles Token ist, das beim Drucken spezieller Tokens erscheint. Wenn du es verbergen möchtest, kannst du `<|im_end|>` als Stop-String in deinen Einstellungen festlegen.

### OLLAMA\_MODELS=unsloth ollama run merged\_file.gguf

Nachdem du llama.cpp gemäß [#run-kimi-k2-thinking-in-llama.cpp](#run-kimi-k2-thinking-in-llama.cpp "mention")installiert hast, 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 %}

\--port 8001 \ `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:Tokenizer-Eigenheiten und Fehlerbehebungen

**7. November 2025: Wir haben das Kimi-Team informiert und den Standard-System-Prompt von** `Du bist Kimi, ein von Moonshot AI erstellter KI-Assistent.` **beim ersten Nutzer-Prompt nicht angezeigt! behoben** Tool Calling mit GLM 4.7 <https://huggingface.co/moonshotai/Kimi-K2-Thinking/discussions/12>

Großen Dank an das Moonshot Kimi-Team für ihre extrem schnelle Reaktionszeit auf unsere Anfragen und dafür, das Problem so schnell wie möglich zu beheben!

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

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

Wenn du die alten Checkpoints heruntergeladen hast – keine Sorge – lade einfach das erste GGUF-Split herunter, das geändert wurde. ODER wenn du keine neuen Dateien herunterladen möchtest, mache:

```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 Ausprobieren - <mark style="background-color:green;">**er verhält sich größtenteils ähnlich wie der Tokenizer von GPT-4o**</mark>! Wir sehen zuerst 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 Überprüfung stellen wir fest, dass Kimi K2 dem Regex des GPT-4o-Tokenizers nahezu identisch ist, welcher zu finden ist in [llama.cpp Quellcode](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 Handhabung von "Han" oder chinesischen Zeichen zu sein, mit der Kimis Tokenizer stärker umgeht. [Der PR](https://github.com/ggml-org/llama.cpp/pull/14654) von <https://github.com/gabriellarson> behandelt diese Unterschiede gut nach einigen [Diskussionen hier](https://github.com/ggml-org/llama.cpp/issues/14642#issuecomment-3067324745).

<mark style="background-color:green;">**Wir stellen auch fest, dass das korrekte EOS-Token nicht \[EOS] sein sollte, sondern vielmehr <|im\_end|>, was wir ebenfalls in unseren Modellkonversionen korrigiert 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.

### 🌙 Offiziell empfohlene Einstellungen:

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

* Setze das <mark style="background-color:green;">**Temperatur 0,6**</mark> um Wiederholungen und Inkohärenz zu reduzieren.
* Ursprünglicher Standard-System-Prompt ist:

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

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

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

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

Kimi Chat verwendet ein BOS (Beginning-of-Sentence-Token). Die Rollen System, Nutzer und Assistent sind alle eingerahmt mit `<|im_middle|>` was interessant ist, und jede 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 konversationellen Grenzen 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 solcher, die nicht imatrix-basiert oder dynamisch sind, nutze unseren Kalibrierungsdatensatz, der speziell für konversationelle, Kodierungs- und Schlussfolgerungsaufgaben optimiert ist.

<table data-full-width="false"><thead><tr><th>MoE Bits</th><th>Typ + Link</th><th>Platzbedarf auf Datenträger</th><th>Details</th></tr></thead><tbody><tr><td>1,66bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-TQ1_0">UD-TQ1_0</a></td><td><strong>245GB</strong></td><td>1,92/1,56bit</td></tr><tr><td>1,78bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ1_S">UD-IQ1_S</a></td><td><strong>281GB</strong></td><td>2,06/1,56bit</td></tr><tr><td>1,93bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ1_M">UD-IQ1_M</a></td><td><strong>304GB</strong></td><td>2.5/2.06/1.56</td></tr><tr><td>2,42bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ2_XXS">UD-IQ2_XXS</a></td><td><strong>343GB</strong></td><td>2,5/2,06bit</td></tr><tr><td>2,71bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q2_K_XL">empfehlen die Verwendung unseres 2,7-Bit Dynamic Quant</a></td><td><strong>381GB</strong></td><td>3,5/2,5bit</td></tr><tr><td>3,12bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ3_XXS">UD-IQ3_XXS</a></td><td><strong>417GB</strong></td><td>3,5/2,06bit</td></tr><tr><td>3,5bit</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>452GB</strong></td><td>4,5/3,5bit</td></tr><tr><td>4,5bit</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>588GB</strong></td><td>5,5/4,5bit</td></tr><tr><td>5,5bit</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>732GB</strong></td><td>6,5/5,5bit</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. Hole dir die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Du kannst auch den Build-Anweisungen unten folgen. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn du keine GPU hast oder nur CPU-Inferenz möchtest.

```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 du `llama.cpp` direkt zum Laden von Modellen 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 `llama.cpp` um an einen bestimmten Ort zu speichern.\ <mark style="background-color:green;">**Um das neue September-2025-Update 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-Schichten auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Schichten auf einer GPU unterbringen, was die Generationsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Schichten zu verschieben, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert Up- und Down-Projektions-MoE-Schichten aus.

Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur Up-Projektions-MoE-Schichten aus.

Und schließlich lagern Sie alle Schichten über `-ot ".ffn_.*_exps.=CPU"` aus.

Sie können auch den Regex 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-Schichten auszulagern, aber nur ab der 6. Schicht.
{% 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. Laden Sie das Modell herunter (nach der Installation `pip install huggingface_hub hf_transfer` ). Sie können wählen `UD-TQ1_0`(dynamisches 1,8bit Quant) oder andere quantisierte Versionen wie `Q2_K_XL` Q4\_K\_XL <mark style="background-color:green;">**wir empfehlen die Verwendung unseres 2-Bit Dynamic Quants**</mark><mark style="background-color:green;">**&#x20;**</mark><mark style="background-color:green;">**`empfehlen die Verwendung unseres 2,7-Bit Dynamic Quant`**</mark><mark style="background-color:green;">**&#x20;**</mark><mark style="background-color:green;">**UD-Q2\_K\_XL**</mark>. Mehr 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 Ratenbegrenzung verursachen, also 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*"], # Dynamic 1bit (281GB) Verwende "*UD-Q2_K_XL*" für Dynamic 2bit (381GB)
)
```

{% endcode %}

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

4. Führe beliebige Prompts aus.
5. Bearbeiten `--threads -1` für die Anzahl der CPU-Threads (standardmäßig ist es auf die maximale Anzahl der CPU-Threads gesetzt), `für die Anzahl der CPU-Threads bearbeiten,` --ctx-size 16384 `--n-gpu-layers 99` für GPU-Auslagerung, auf wie viele Schichten. Setze es auf 99 in Kombination mit MoE-CPU-Auslagerung, um die beste Leistung zu erzielen. Versuche es anzupassen, wenn deine GPU keinen Speicher mehr hat. Entferne es auch, wenn du nur CPU-Inferenz nutzt.

{% 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 unsere 1,58bit Quants für DeepSeek R1 bereitgestellt wurden. Wir fanden Kimi K2 eines der wenigen Modelle, die alle unsere Aufgaben im One-Shot gelöst haben, einschließlich dieses hier, [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 es, das LLM zu bitten, ein Flappy Bird-Spiel zu erstellen, aber einige spezifische Anweisungen zu befolgen:

{% code overflow="wrap" %}

```
Erstelle ein Flappy Bird-Spiel in Python. Du musst Folgendes einbeziehen:
1. Du musst pygame verwenden.
2. Die Hintergrundfarbe sollte zufällig gewählt sein und einen hellen Ton haben. Beginne mit einer hellblauen Farbe.
3. Mehrmaliges Drücken der LEERTASTE beschleunigt den 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. Platziere unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.
6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du Rohre passiert und nicht getroffen hast.
7. Erzeuge zufällig platzierte Rohre mit genügend Abstand. Färbe sie zufällig dunkelgrün oder hellbraun oder in einem dunklen Grauton.
8. Wenn du verlierst, zeige die Bestpunktzahl. Mache den Text innerhalb des Bildschirms. Das Drücken von q oder Esc beendet das Spiel. Neustarten erfolgt durch erneutes Drücken der LEERTASTE.
Das endgültige Spiel sollte innerhalb eines Markdown-Abschnitts in Python sein. Überprüfe deinen Code auf Fehler und behebe sie vor dem finalen Markdown-Abschnitt.
```

{% endcode %}

Du kannst die dynamischen Quants auch über den Heptagon-Test testen, laut [r/Localllama](https://www.reddit.com/r/LocalLLaMA/comments/1j7r47l/i_just_made_an_animation_of_a_ball_bouncing/) welches das Modell darin testet, eine grundlegende Physik-Engine zu erstellen, um Kugeln rotierend in einer sich bewegenden, eingeschlossenen Heptagon-Form zu simulieren.

<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 Kugeln im Heptagon sollten sich bewegen. Die Prompt ist unten:

{% code overflow="wrap" %}

```
Schreibe ein Python-Programm, das 20 Bälle zeigt, die in einem rotierenden Heptagon aufspringen:\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 vom Zentrum des Heptagons.\n- 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 sollten von Schwerkraft und Reibung beeinflusst werden und müssen realistisch von den rotierenden Wänden abprallen. Es sollte auch Kollisionen zwischen den Bällen geben.\n- Das Material aller Bälle bestimmt, dass ihre Aufprall-Rücksprunghöhe den Radius des Heptagons nicht überschreiten wird, aber höher als der Ballradius sein soll.\n- Alle Bälle rotieren mit Reibung, die Zahlen auf den Bällen können verwendet werden, um die Rotation der Bälle anzuzeigen.\n- Das Heptagon dreht sich um sein Zentrum, und die Drehgeschwindigkeit beträgt 360 Grad pro 5 Sekunden.\n- Die Größe des Heptagons sollte groß genug sein, um alle Bälle zu enthalten.\n- Verwende nicht die pygame-Bibliothek; implementiere Kollisionsdetektionsalgorithmen und Kollisionsantworten etc. selbst. Die folgenden Python-Bibliotheken sind erlaubt: tkinter, math, numpy, dataclasses, typing, sys.\n- Alle Codes sollten in einer einzigen Python-Datei abgelegt werden.
```

{% endcode %}


---

# Agent Instructions: Querying This Documentation

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

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

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

The question should be specific, self-contained, and written in natural language.
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.