> 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/kimi-k2.7-code.md).

# Kimi K2.7 Code - Wie man es lokal ausführt

Kimi K2.7 Code ist das agentische Coding-Modell von Moonshot AI, aufbauend auf [K2.6](/docs/de/modelle/kimi-k2.6.md) um die Aufgabenerledigung zu verbessern und dabei \~30 % weniger Denk-Tokens zu verwenden. Das 1T-Parameter- (32B aktiv) MoE-Modell unterstützt nur Denken, Vision und 256K Kontext. Es liefert SOTA-Open-Performance über Vision-, Coding-, agentische, Langkontext- und Chat-Aufgaben hinweg. Volle Präzision erfordert 605 GB Speicherplatz; Unsloth [Dynamisch](/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs.md) 2-Bit erfordert **325 GB (-48 %)**. Ausführen [**Kimi-K2.7-Code-GGUF**](https://huggingface.co/unsloth/Kimi-K2.7-Code-GGUF) über Unsloth Studio oder llama.cpp.

[**Unsloth Dynamisch**](/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs.md) **Quantisierungen** hebt wichtige Schichten auf 8-Bit an und 1-Bit benötigt **310 GB+ VRAM/RAM** Setups**.** Für **verlustfrei** Für Kimi-K2.6 verwenden Sie Q8 (`UD-Q8_K_XL`), was nur **10 GB größer** als Q4 (`UD-Q4_K_XL`). Sie können Kimi K2.7 Code über einen Mac Studio oder [DGX Station](/docs/de/blog/dgx-station.md).

**Tabelle: Hardwareanforderungen** (Einheiten = Gesamtspeicher: RAM + VRAM oder einheitlicher Speicher)

| Dynamisch 1-Bit | Dynamisch 2-Bit | Dynamisch Q3 | Q8 (verlustfrei) |
| --------------- | --------------- | ------------ | ---------------- |
| 310 GB          | 325-350 GB      | 385-470 GB   | 605 GB           |

### 📊 Quantisierungsanalyse

Wie [Kimi-K2.6](/docs/de/modelle/kimi-k2.6.md), `UD-Q8_K_XL` ist verlustfrei, weil Kimi int4 für MoE-Gewichte und BF16 für alles andere verwendet, und `Q8_K_XL` folgt dem. Daher verwenden wir für die Kimi-K2.6-Konvertierung die gleiche Dynamic-Methodik. `UD-Q4_K_XL` ist ähnlich, außer dass die verbleibenden Tensoren `Q8_0`, sodass es nahezu Vollpräzision ist und 600 GB RAM/VRAM erfordert. `UD-Q8_K_XL` ist 'wirklich verlustfrei'.

| Messung       | UD-Q2\_K\_XL | UD-Q4\_K\_XL | UD-Q8\_K\_XL (verlustfrei) |
| ------------- | ------------ | ------------ | -------------------------- |
| Speicherplatz | 339 GB       | 584 GB       | 595 GB                     |
| Perplexity    | \~2.4131     | \~1.8420     | \~1.8419                   |

Wir folgten [jukofyork](https://github.com/jukofyork)'s Erkenntnis, dass `const float d = max / -7;` anstelle des Standardwerts `const float d = max / -8;` während des Quantisierungsprozesses nur auf den MoE-Schichten. Dieser Bijektions-Patch auf INT4-nativen MoEs ermöglicht dem `Q4_0` Quant-Typ, den absoluten Fehler von 1,8 % auf nahezu 0 % (Epsilon) zu reduzieren. Unten ist zum Beispiel das Histogramm für Kimi-K2.7-Code zu sehen, und man kann sehen, dass -8 vollständig ungenutzt ist:

<figure><img src="/files/bf3cd2572118f7b87ed6ba5bfef434fb84b5adfb" alt=""><figcaption></figcaption></figure>

Beachten Sie, dass wir auch die anderen Schichten in BF16 belassen und nicht das smarte „Q4\_0“. Unten zeigen wir die Fehlerdiagramme für beide im Vergleich zur BF16-Baseline. `UD-Q8-K_XL` ist wirklich „verlustfrei“ mit einem winzigen Unterschied in Maschinen-Epsilon beim Konvertieren von Q4\_0 zu BF16. Daher hat Q4\_K\_XL aufgrund der Verwendung von Q8\_0 durchaus einen gewissen Quantisierungsfehler, während Q8\_K\_XL nahezu verlustfrei ist, abgesehen von der BF16-Rundung.

<figure><img src="/files/af3805fd56cbdc4d192a9820fef00b84044c9943" alt=""><figcaption></figcaption></figure>

Für Q4\_K\_XL plotten wir außerdem auch den Fehler pro Tensor von Q8\_0 gegenüber BF16. Im Allgemeinen gibt es zwischen Q8\_K\_XL (nahezu verlustfrei) und Q4\_K\_XL einen gewissen Fehler, aber nicht viel.

<figure><img src="/files/7e3bec741161934f21cf0e372de8d013eea777bb" alt=""><figcaption></figcaption></figure>

### :gear: Anleitung

Kimi K2.7 Code ist **nur für das Denken**, mit **`preserve_thinking` immer aktiviert**. Der Instant-Modus wird nicht unterstützt.

| Standard (Denkmodus) |
| -------------------- |
| temperature = 1.0    |
| top\_p = 0.95        |

* Empfohlene Kontextlänge = `98,304` (bis zu `262,144`)

Wenn das Modell passt, erhalten Sie mit B200s >100 Tokens/s. Wir empfehlen `UD-Q2_K_XL` (345 GB) als guten Kompromiss zwischen Größe und Qualität. Beste Faustregel: RAM+VRAM ≈ die Quant-Größe; andernfalls funktioniert es trotzdem, nur langsamer wegen des Auslagerns.

#### Chat-Vorlage für Kimi K2.7-Code

Ausführen `tokenizer.apply_chat_template([{\"role\": \"user\", \"content\": \"Was ist 1+1?\"},])` ergibt:

{% code overflow="wrap" %}

```
<|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|><|im_assistant|>assistant<|im_middle|><think>
```

{% endcode %}

Wenn wir auch Werkzeuge wie in [Tool Calling Guide](/docs/de/grundlagen/tool-calling-guide-for-local-llms.md), dann sehen wir Folgendes:

{% code overflow="wrap" expandable="true" %}

```
<|im_system|>tool_declare<|im_middle|># Werkzeuge

## Funktionen
namespace functions {
// Zwei Zahlen addieren.
type add_number = (_: {
  // Die erste Zahl.
  a: string,
  // Die zweite Zahl.
  b: string
}) => any;
// Zwei Zahlen multiplizieren.
type multiply_number = (_: {
  // Die erste Zahl.
  a: string,
  // Die zweite Zahl.
  b: string
}) => any;
// Zwei Zahlen subtrahieren.
type subtract_number = (_: {
  // Die erste Zahl.
  a: string,
  // Die zweite Zahl.
  b: string
}) => any;
// Schreibt eine zufällige Geschichte.
type write_a_story = (_: {}) => any;
// Führt Operationen im Terminal aus.
type terminal = (_: {
  // Der Befehl, den Sie ausführen möchten, z. B. `ls`, `rm`, ...
  command: string
}) => any;
// Ruft einen Python-Interpreter mit etwas Python-Code auf, der ausgeführt wird.
type python = (_: {
  // Der auszuführende Python-Code
  code: string
}) => any;
}
<|im_end|><|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|><|im_assistant|>assistant<|im_middle|><think>
```

{% endcode %}

## Anleitung zum Ausführen von Kimi K2.7 Code

### 🦥 Kimi-K2.7-Code in Unsloth Studio ausführen

Kimi K2.7 Code kann in [Unsloth Studio](/docs/de/neu/studio.md), einer Open-Source-Web-UI für lokale KI. **Unsloth Studio lagert automatisch in den RAM aus und erkennt Multi-GPU-Setups**. Mit Unsloth Studio können Sie Modelle lokal auf **MacOS, Windows**, Linux und:

{% columns %}
{% column %}

* Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle
* [**Selbstheilendes** Tool-Calling](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche**
* [**Codeausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash)
* [Automatische Inferenz](/docs/de/neu/studio.md#model-arena) Parameterabstimmung (temp, top-p usw.)
* Schnelle CPU- + GPU-Inferenz über llama.cpp
* [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70 % weniger VRAM
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/89ac45c1d5144736e3036cb7225d0c867534603a" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}
**Unsloth installieren und starten**

Zur Installation führen Sie in Ihrem Terminal Folgendes aus:

macOS, Linux, WSL:

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

Windows PowerShell:

```bash
irm https://unsloth.ai/install.ps1 | iex
```

**Unsloth starten**

MacOS, Linux, WSL und Windows:

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

Dann öffnen Sie `http://127.0.0.1:8888` (oder Ihre spezifische URL) in Ihrem Browser.
{% endstep %}

{% step %}
**Kimi K2.7-Code suchen und herunterladen**

Unsloth Studio lagert automatisch in den RAM aus und erkennt Multi-GPU-Setups. Beim ersten Start müssen Sie ein Passwort erstellen, um Ihr Konto zu sichern und sich später erneut anzumelden.

Gehen Sie dann zur [Unsloth Chat](/docs/de/neu/studio/chat.md) Registerkarte und suchen Sie nach **Kimi-K2.7 Code** in der Suchleiste und laden Sie das gewünschte Modell und die gewünschte Quantisierung herunter. Stellen Sie sicher, dass Sie genügend Rechenleistung haben, um das Modell auszuführen.

<div data-with-frame="true"><figure><img src="/files/08238f5c81b3500f30dc46a66893e12b8b61038d" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}
**Kimi-K2.7-Code ausführen**

Die Inferenzparameter sollten bei der Verwendung von Unsloth Studio automatisch gesetzt werden, du kannst sie jedoch weiterhin manuell ändern. Du kannst außerdem die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten.

Für weitere Informationen können Sie unsere [Inferenzanleitung für Unsloth Studio](/docs/de/neu/studio/chat.md).

<div data-with-frame="true"><figure><img src="/files/60be6fbac06ea3e689fd70e7f46fb3f791344534" alt="" width="563"><figcaption><p>Beispiel für Qwen3.6 mit Tool-Calling</p></figcaption></figure></div>
{% endstep %}
{% endstepper %}

### 🦙 Kimi K2.7 Code in llama.cpp ausführen

Für diese Anleitung werden wir die `UD-Q2_K_XL` Quantisierung verwenden, die mindestens 345 GB RAM erfordert. Fühlen Sie sich frei, den Quantisierungstyp zu ändern. GGUF: [**Kimi-K2.7-Code-GGUF**](https://huggingface.co/unsloth/Kimi-K2.7-Code-GGUF)

Für diese Tutorials werden wir [llama.cpp](llama.cpphttps://github.com/ggml-org/llama.cpp) für schnelle lokale Inferenz, insbesondere wenn Sie eine CPU haben.

{% stepper %}
{% step %}
Holen Sie sich die neueste `llama.cpp` **ein** [**GitHub hier**](https://github.com/ggml-org/llama.cpp). Sie können auch den untenstehenden Build-Anweisungen folgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen. **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
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
```

{% endstep %}

{% step %}
**Lassen Sie uns zuerst ein Bild holen!** Sie können auch Bilder hochladen. Wir werden <https://raw.githubusercontent.com/unslothai/unsloth/refs/heads/main/images/unsloth%20made%20with%20love.png>, das einfach unser Mini-Logo ist und zeigt, wie Feinabstimmungen mit Unsloth erstellt werden:

{% code overflow="wrap" %}

```bash
wget https://raw.githubusercontent.com/unslothai/unsloth/refs/heads/main/images/unsloth%20made%20with%20love.png -O unsloth.png
```

{% endcode %}

<figure><img src="/files/160964fe46d3d435f00c2ea49f3597248b55aef1" alt="" width="188"><figcaption></figcaption></figure>

Holen wir uns das zweite Bild unter <https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg>

{% code overflow="wrap" %}

```bash
wget https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg -O picture.png
```

{% endcode %}

<figure><img src="/files/9348b2f2ccd13a6029ac983226c9dc6671d3bc23" alt="" width="188"><figcaption></figcaption></figure>
{% endstep %}

{% step %}
Sie können jetzt `llama.cpp` direkt verwenden, um Modelle zu laden und herunterzuladen, genau wie `ollama run`. Wählen Sie zunächst den gewünschten Quantisierungstyp aus, zum Beispiel `Q2_K_XL`. Verwenden Sie außerdem `export LLAMA_CACHE="folder"` um zu erzwingen `llama.cpp` dass es an einem bestimmten Speicherort gespeichert wird. Beachten Sie, dass dieser Download-Vorgang sehr langsam sein kann, daher ist es wahrscheinlich am besten, den manuellen Download-Prozess im nächsten Abschnitt zu verwenden.

```bash
export LLAMA_CACHE=\"unsloth/Kimi-K2.7-Code-GGUF\"
./llama.cpp/llama-cli \\
    -hf unsloth/Kimi-K2.7-Code-GGUF:UD-Q2_K_XL \\
    --temp 1.0 \\
    --top-p 0.95
```

{% endstep %}

{% step %}
Wenn Sie das Modell manuell herunterladen möchten, können wir das Modell über den folgenden Code herunterladen (nach der Installation von `pip install huggingface_hub`). Wenn Downloads hängen bleiben, siehe: [Hugging Face Hub, XET-Debugging](/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

```bash
hf download unsloth/Kimi-K2.7-Code-GGUF \\
    --local-dir unsloth/Kimi-K2.7-Code-GGUF \\
    --include "*mmproj-F16*" \\
    --include "*UD-Q2_K_XL*" # Verwenden Sie "*UD-Q8_K_XL*" für volle Präzision
```

{% endstep %}

{% step %}
Dann führen Sie das Modell im Gesprächsmodus aus:

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \\
    --model unsloth/Kimi-K2.7-Code-GGUF/UD-Q2_K_XL/Kimi-K2.7-Code-UD-Q2_K_XL-00001-of-00008.gguf \\
    --mmproj unsloth/Kimi-K2.7-Code-GGUF/mmproj-F16.gguf \\
    --temp 1.0 \\
    --top-p 0.95
```

{% endcode %}

Dann sehen Sie Folgendes:\
![](/files/b31615947bd8301dff15e314cff32644a277c1a1)
{% endstep %}

{% step %}
Dann verwenden Sie `/image` um beide Bilder zu laden und zu fragen: „Was ist dieses Bild?“

<figure><img src="/files/e3cc058310f6fa351b6b8fe38b17378ac413e0ca" alt=""><figcaption></figcaption></figure>

und Sie erhalten etwas Ähnliches wie unten:

<figure><img src="/files/2f9f31c4e278387e4035b1eee63a828df66b5d4d" alt=""><figcaption></figcaption></figure>

Beim zweiten Bild des Faultiers:

<figure><img src="/files/71a11ee65021bdce4acc63dad5ff2a9c0a9587eb" alt=""><figcaption></figcaption></figure>

Wodurch Sie Folgendes bekommen:

<figure><img src="/files/758d37c00e4c1d084e0d1a14e2e790db0a9c6df1" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

### 📊 Benchmarks

Weiter unten können Sie Benchmarks in Tabellenform ansehen:

<div data-with-frame="true"><figure><img src="/files/774f343b28b6c8f915c9d72b6e235043a7ab2186" alt="" width="563"><figcaption></figcaption></figure></div>

|       Benchmark      | Kimi K2.7 Code | Kimi K2.6 | GPT-5.5 | Claude Opus 4.8 |
| :------------------: | :------------: | :-------: | :-----: | :-------------: |
|  **Programmierung**  |                |           |         |                 |
|  Kimi Code Bench v2  |      62.0      |    50.9   |   69.0  |       67.4      |
|    Programm-Bench    |      53.6      |    48.3   |   69.1  |       63.8      |
|    MLS Bench Lite    |      35.1      |    26.7   |   35.5  |       42.8      |
|     **Agentisch**    |                |           |         |                 |
| Kimi Claw 24/7 Bench |      46.9      |    42.9   |   52.8  |       50.4      |
|       MCP Atlas      |      76.0      |    69.4   |   79.4  |       81.3      |
| MCP Mark verifiziert |      81.1      |    72.8   |   92.9  |       76.4      |


---

# 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, and the optional `goal` query parameter:

```
GET https://unsloth.ai/docs/de/modelle/kimi-k2.7-code.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.