> 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: Anleitung zum lokalen Ausführen

{% hint style="success" %}
Kimi-K2-Thinking wurde veröffentlicht. Lies unseren [Thinking-Leitfaden](#kimi-k2-thinking-guide) oder greife hier auf [GGUFs zu](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-Performance bei Wissens-, Reasoning-, 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 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-Performance ausführen. Sieh dir an, wie unsere Dynamic 1–2-Bit-GGUFs bei [Coding-Benchmarks hier abschneiden](/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 Voraussetzungen

{% hint style="info" %}
Du benötigst **247 GB Festplattenspeicher** um den 1-Bit-Quant 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 %}

Der 1,8-Bit-(UD-TQ1\_0)-Quant passt auf eine 1x-24-GB-GPU (wobei alle MoE-Layer in den System-RAM oder auf eine schnelle Festplatte ausgelagert werden). Rechne mit etwa \~1–2 Tokens/s mit diesem Setup, wenn du zusätzlich 256 GB RAM hast. Der vollständige Kimi K2 Q8 Quant ist 1,09 TB groß und benötigt mindestens 8 x H200 GPUs.

Für optimale Leistung benötigst du mindestens **247 GB einheitlichen Speicher oder 247 GB kombinierten RAM+VRAM** für 5+ Tokens/s. Wenn du weniger als 247 GB kombinierten RAM+VRAM hast, wird die Geschwindigkeit des Modells definitiv beeinträchtigt.

**Wenn du keine 247 GB RAM+VRAM hast, keine Sorge!** llama.cpp hat von Natur aus **Festplatten-Offloading**, sodass es über mmaping weiterhin funktioniert, nur langsamer - zum Beispiel hast du zuvor vielleicht 5 bis 10 Tokens/Sekunde bekommen, jetzt sind es unter 1 Token.

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

{% hint style="success" %}
Für beste Leistung sollte dein kombiniertes VRAM + RAM = der Größe des heruntergeladenen Quants entsprechen. Falls nicht, funktioniert es weiterhin per 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 in 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 höhere Bit-Quantisierung 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)sind dies die empfohlenen Einstellungen für die Kimi-K2-Thinking-Inferenz:

* Setzen Sie <mark style="background-color:green;">**Temperatur 1,0**</mark> um Wiederholungen und Inkohärenz zu reduzieren.
* Empfohlene Kontextlänge = 98.304 (bis zu 256K)
* Hinweis: Die Verwendung verschiedener 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 Tokens mit niedrigen Wahrscheinlichkeiten zu unterdrücken.
{% endhint %}

Zum Beispiel bei einer Benutzernachricht von „Was ist 1+1?“, erhalten wir:

{% code overflow="wrap" %}

```
<|im_system|>system<|im_middle|>Du bist Kimi, ein KI-Assistent, erstellt von Moonshot AI.<|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 die neueste Aktualisierung 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 untenstehenden Build-Anweisungen 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` und fahre 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). Dies ist ähnlich zu `ollama run` . Verwenden Sie `export LLAMA_CACHE="folder"` um zu erzwingen, dass `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. Das oben Genannte wird etwa 8 GB GPU-Speicher verwenden. Wenn du ungefähr 360 GB kombinierten GPU-Speicher hast, entferne `-ot ".ffn_.*_exps.=CPU"` um maximale Geschwindigkeit zu erhalten!

{% hint style="info" %}
Bitte probieren Sie `-ot ".ffn_.*_exps.=CPU"` verwenden, 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"` Dies lagert die MoE-Layer für Up- und Down-Projektionen aus.

Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus.

Und schließlich lagern Sie alle Layer aus via `-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 der 6. Schicht.
{% endhint %}

3. Lade das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Wir empfehlen, unseren 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 eine Ratenbegrenzung auslösen, 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 Dynamic 2bit (381GB)
)
```

{% endcode %}

{% hint style="info" %}
Wenn du feststellst, dass Downloads bei etwa 90 bis 95 % hängen bleiben, siehe bitte <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 es auf die maximale Anzahl CPU-Threads gesetzt), `--ctx-size 16384` für die Kontextlänge, `--n-gpu-layers 99` für das GPU-Offloading, für wie viele Schichten. Setze es auf 99 zusammen mit MoE-CPU-Offloading, um die beste Leistung zu erhalten. Versuche, es anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne es außerdem, 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 *thinking* Tags gibt, wenn du das Modell ausführst. Das ist normal und beabsichtigtes Verhalten.

In deinem `llama.cpp` Skript stelle sicher, dass du das `--special` Flag ganz am Ende deines Befehls einfügst. 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 Ausgeben spezieller Tokens erscheint. Wenn du es ausblenden möchtest, kannst du `<|im_end|>` als Stop-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")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 %}

Verwenden Sie anschließend die Python-Bibliothek von OpenAI nach `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 informiert und den Standard-System-Prompt von** `Du bist Kimi, ein KI-Assistent, erstellt von Moonshot AI.` **erscheint nicht beim ersten Benutzerprompt!** Siehe <https://huggingface.co/moonshotai/Kimi-K2-Thinking/discussions/12>

Ein riesiges Dankeschön an das Moonshot-Kimi-Team für ihre extrem schnelle Antwortzeit auf unsere Anfragen und dafür, dass sie das Problem so schnell wie möglich behoben 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 - keine Sorge - 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
```

Mit dem Kimi-K2-Tokenizer herumzuspielen war interessant - <mark style="background-color:green;">**er verhält sich größtenteils ähnlich wie der Tokenizer von GPT-4o**</mark>! Zuerst 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 GPT-4o-Tokenizers nahezu identisch ist, den man in [llama.cpps 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 Zahlen (9, 99, 999) und verwenden ähnliche Muster. Der einzige Unterschied scheint die Behandlung von "Han"- oder chinesischen Zeichen zu sein, mit denen Kimis Tokenizer stärker umgeht. [Der PR](https://github.com/ggml-org/llama.cpp/pull/14654) von <https://github.com/gabriellarson> geht mit diesen Unterschieden nach einigen [Diskussionen hier](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 ebenfalls 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 Kimi K2-Inferenz:

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

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

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

{% hint style="success" %}
Wir empfehlen, <mark style="background-color:green;">**min\_p auf 0,01 zu setzen**</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 (Beginn des Satzes). Die Rollen System, Benutzer und Assistent sind alle eingeschlossen mit `<|im_middle|>` was interessant ist, und jede erhält ihr eigenes entsprechendes 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 solcher, die nicht auf imatrix basieren oder dynamisch sind, verwenden unseren Kalibrierungsdatensatz, der speziell für Gesprächs-, 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. Hole dir die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Du kannst auch den untenstehenden Build-Anweisungen 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). Dies ist ähnlich zu `ollama run` . Verwenden Sie `export LLAMA_CACHE="folder"` um zu erzwingen, dass `llama.cpp` um an einem bestimmten Speicherort 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' in 'Kimi-K2-Instruct-0905'.**</mark>

{% hint style="info" %}
Bitte probieren Sie `-ot ".ffn_.*_exps.=CPU"` verwenden, 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"` Dies lagert die MoE-Layer für Up- und Down-Projektionen aus.

Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus.

Und schließlich lagern Sie alle Layer aus via `-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 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. Lade das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst `UD-TQ1_0`(Dynamic-1,8-Bit-Quant) oder andere quantisierte Versionen wie `Q2_K_XL` . Wir <mark style="background-color:green;">**empfehlen die Verwendung unseres 2-Bit-Dynamic-Quants**</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 eine Ratenbegrenzung auslösen, 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*"], # 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 % hängen bleiben, siehe bitte <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 es auf die maximale Anzahl CPU-Threads gesetzt), `--ctx-size 16384` für die Kontextlänge, `--n-gpu-layers 99` für das GPU-Offloading, für wie viele Schichten. Setze es auf 99 zusammen mit MoE-CPU-Offloading, um die beste Leistung zu erhalten. Versuche, es anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne es außerdem, 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 unsere 1,58-Bit-Qants für DeepSeek R1 bereitgestellt wurden. Wir stellten fest, dass Kimi K2 eines der wenigen Modelle ist, das alle unsere Aufgaben einschließlich dieser in einem Durchlauf löst, [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 dazu zu bringen, ein Flappy-Bird-Spiel zu erstellen, aber unter Befolgung einiger spezifischer Anweisungen:

{% code overflow="wrap" %}

```
Erstelle ein Flappy-Bird-Spiel in Python. Du musst diese Dinge einschließen:
1. Du musst pygame verwenden.
2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton sein. Beginne mit einem hellblauen Farbton.
3. Mehrfaches 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 oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeikommst, ohne sie zu berühren.
7. Erstelle zufällig verteilte Rohre mit genügend Abstand. Färbe sie zufällig dunkelgrün, hellbraun oder in einem dunklen Grauton.
8. Wenn du verlierst, zeige die Bestpunktzahl an. Platziere den Text innerhalb des Bildschirms. Mit q oder Esc beendest du das Spiel. Ein Neustart erfolgt durch erneutes Drücken der LEERTASTE.
Das endgültige Spiel sollte sich in einem Markdown-Abschnitt in Python befinden. Prüfe deinen Code auf Fehler und behebe sie vor dem endgültigen Markdown-Abschnitt.
```

{% endcode %}

Du kannst die Dynamic Quants auch über den Heptagon-Test testen, gemäß [r/Localllama](https://www.reddit.com/r/LocalLLaMA/comments/1j7r47l/i_just_made_an_animation_of_a_ball_bouncing/) der das Modell beim Erstellen einer einfachen Physik-Engine testet, um Bälle zu simulieren, die in einer sich bewegenden, geschlossenen Heptagon-Form 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, dass sich das Heptagon dreht und sich die Bälle im Heptagon bewegen. Der Prompt steht unten:

{% code overflow="wrap" %}

```
Schreibe ein Python-Programm, das 20 Bälle zeigt, die in einem rotierenden Heptagon herumhüpfen:\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 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-Sprunghöhe den Radius des Heptagons nicht überschreiten darf, aber höher als der Ballradius sein muss.\n- Alle Bälle rotieren mit Reibung, die Zahlen auf dem Ball können verwendet werden, um die Rotation 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 aufzunehmen.\n- Verwende nicht die pygame-Bibliothek; implementiere Kollisionsdetektionsalgorithmen und Kollisionsreaktion usw. selbst. Die folgenden Python-Bibliotheken sind erlaubt: tkinter, math, numpy, dataclasses, typing, sys.\n- Der gesamte Code sollte 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 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.