# Kimi K2.5: Leitfaden zum Ausführen lokal

Kimi-K2.5 ist das neue Modell von Moonshot, das SOTA-Performance bei Vision-, Coding-, agentischen und Chat-Aufgaben erreicht. Das hybride Reasoning-Modell mit 1T Parametern benötigt 600 GB Festplattenspeicher, während die quantisierte **Unsloth Dynamic 1,8-Bit** Version dies auf 240 GB reduziert (-60 % Größe)**:** [**Kimi-K2.5-GGUF**](https://huggingface.co/unsloth/Kimi-K2.5-GGUF)

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

### :gear: Empfohlene Voraussetzungen

{% hint style="info" %}
Du benötigst >**240 GB Festplattenspeicher** um den 1-Bit-Quant auszuführen!

Für die beste Leistung stelle sicher, dass dein insgesamt verfügbarer Speicher (VRAM + Systemspeicher) größer ist als die Größe der quantisierten Modelldatei, die du herunterlädst. Falls nicht, kann llama.cpp weiterhin über SSD/HDD-Offloading ausgeführt werden, aber die Inferenz wird langsamer sein.
{% endhint %}

Der 1,8-Bit-(UD-TQ1\_0)-Quant läuft auf einer einzelnen 24-GB-GPU, wenn du alle MoE-Layer in den System-RAM (oder auf eine schnelle SSD) auslagerst. Mit \~256 GB RAM kannst du mit \~10 Token/s rechnen. Das vollständige Kimi-K2.5-Modell ist 630 GB groß und benötigt typischerweise mindestens 4× H200-GPUs.

Wenn das Modell hineinpasst, erhältst du >40 Token/s bei Verwendung einer B200.

Um das Modell in nahezu **voller Präzision**auszuführen, kannst du die 4-Bit- oder 5-Bit-Quants verwenden. Du kannst auch jeden höheren Wert verwenden, nur um auf Nummer sicher zu gehen.

Für starke Leistung solltest du >240 GB einheitlichen Speicher (oder kombinierte RAM+VRAM) anpeilen, um 10+ Token/s zu erreichen. Wenn du darunter liegst, funktioniert es zwar, aber die Geschwindigkeit sinkt (llama.cpp kann weiterhin per mmap/Disk-Offload laufen) und kann von \~10 Token/s auf <2 Token/s fallen.

Wir empfehlen UD-Q2\_K\_XL (375 GB) als guten Kompromiss zwischen Größe und Qualität. Beste Faustregel: RAM+VRAM ≈ Quantgröße; andernfalls funktioniert es trotzdem, nur langsamer aufgrund des Offloadings.

## 🥝 Kimi-K2.5-Anleitung ausführen

Kimi-K2.5 benötigt für verschiedene Anwendungsfälle unterschiedliche Sampling-Parameter.

Derzeit gibt es **keine Vision-Unterstützung** für das Modell, aber hoffentlich unterstützt llama.cpp sie bald.

{% 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 %}

### 🌙 Nutzungsanleitung:

Laut Moonshot AI sind dies die empfohlenen Einstellungen für die Inferenz von Kimi K2.5:

| Standard-Einstellungen (Instant-Modus)                             | Thinking-Modus                                                     |
| ------------------------------------------------------------------ | ------------------------------------------------------------------ |
| <mark style="background-color:green;">**temperature = 0.6**</mark> | <mark style="background-color:green;">**temperature = 1.0**</mark> |
| <mark style="background-color:green;">**top\_p = 0.95**</mark>     | <mark style="background-color:green;">**top\_p = 0.95**</mark>     |
| min\_p = 0.01                                                      | min\_p = 0.01                                                      |

* Setzen Sie die **Temperatur 1,0** 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. Und **repeat penalty deaktivieren oder auf 1,0 setzen** falls nötig.
{% endhint %}

#### Chat-Template für Kimi K2.5

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

{% 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|><think>
```

{% endcode %}

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

Kimi-K2.5 kann ausgeführt werden in [Unsloth Studio](/docs/de/neu/studio.md), unserer neuen Open-Source-Web-UI für lokale KI. Mit Unsloth Studio können Sie Modelle lokal ausführen 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**
* [**Code-Ausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash)
* [Automatische Inferenz](/docs/de/neu/studio.md#model-arena) Parameter-Tuning (Temp, Top-p usw.)
* Schnelle CPU-+GPU-Inferenz via 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**

Führen Sie es in Ihrem Terminal aus:

MacOS, Linux, WSL:

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

Windows PowerShell:

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

{% hint style="success" %}
**Die Installation geht schnell und dauert ungefähr 1-2 Minuten.**
{% endhint %}
{% endstep %}

{% step %}
**Unsloth starten**

MacOS, Linux, WSL und Windows:

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

Dann öffnen Sie `http://localhost:8888` in Ihrem Browser.
{% endstep %}

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

Beim ersten Start musst du ein Passwort erstellen, um dein Konto zu sichern, und dich später erneut anmelden. Danach siehst du einen kurzen Einrichtungsassistenten, um ein Modell, einen Datensatz und grundlegende Einstellungen auszuwählen. Du kannst ihn jederzeit überspringen und direkt zum Chat gehen.

Gehen Sie dann zur [Studio Chat](/docs/de/neu/studio/chat.md) Tab und suche nach **Kimi-K2.5** in der Suchleiste und lade dein gewünschtes Modell und den gewünschten Quant herunter. Stelle sicher, dass du genug Rechenleistung hast, um das Modell auszuführen.

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

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

Inferenzparameter sollten bei der Verwendung von Unsloth Studio automatisch gesetzt werden; Sie können sie jedoch weiterhin manuell ändern. Sie können auch die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten.

Weitere Informationen finden Sie in unserer [Unsloth Studio-Inferenzanleitung](/docs/de/neu/studio/chat.md).

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

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

Für diese Anleitung verwenden wir den kleinsten 1-Bit-Quant, der 240 GB groß ist. Du kannst die Quantisierung gerne auf 2-Bit, 3-Bit usw. ändern. Um das Modell in nahezu **voller Präzision**auszuführen, kannst du die 4-Bit- oder 5-Bit-Quants verwenden. Du kannst auch jeden höheren Wert verwenden, nur um auf Nummer sicher zu gehen.

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
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

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

{% hint style="success" %}
`LLAMA_SET_ROWS=1` macht llama.cpp ein wenig schneller! Verwende es! `--fit on` ordnet Modelle automatisch und optimal auf all deinen GPUs und CPUs ein.
{% endhint %}

```bash
export LLAMA_CACHE="unsloth/Kimi-K2.5-GGUF"
LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \
    -hf unsloth/Kimi-K2.5-GGUF:UD-TQ1_0\
    --temp 1.0 \
    --min-p 0,01 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --seed 3407
```

3. `--fit on` wird das Modell automatisch an dein System anpassen. Wenn du nicht `--fit on` und du etwa 360 GB gemeinsamen GPU-Speicher hast, entferne `-ot ".ffn_.*_exps.=CPU"` um maximale Geschwindigkeit zu erreichen.

{% hint style="info" %}
Verwende `--fit on` für automatisches Einpassen auf GPUs und CPUs. Wenn das nicht funktioniert, siehe unten:

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.5-GGUF](https://huggingface.co/unsloth/Kimi-K2.5-GGUF) Wenn Downloads hängen bleiben, siehe [Hugging Face Hub, XET-Debugging](/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

{% code overflow="wrap" %}

```bash
pip install -U huggingface_hub
hf download unsloth/Kimi-K2.5-GGUF \
    --local-dir unsloth/Kimi-K2.5-GGUF \
    --include "*UD-TQ1_0*" # Verwende "*UD-Q2_K_XL*" für Dynamic 2bit
```

{% endcode %}

{% hint style="info" %}
Wenn du feststellst, dass Downloads bei 90 bis 95 % oder so hängen bleiben, sieh dir bitte unsere [Fehlerbehebungsanleitung](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  `--ctx-size 16384` für die Kontextlänge an. Du kannst dies auch weglassen für die automatische Ermittlung der Kontextlänge über `--fit on`

{% code overflow="wrap" %}

```bash
LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \
    --temp 1.0 \
    --min-p 0,01 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --seed 3407
```

{% endcode %}

6. Versuche beispielsweise: "Erstelle ein Flappy-Bird-Spiel in HTML", und du erhältst:

{% columns %}
{% column width="33.33333333333333%" %}

<figure><img src="/files/81fa5d33464bfb75a62ccf39eebd3da2fa3250f6" alt="" width="188"><figcaption></figcaption></figure>
{% endcolumn %}

{% column width="66.66666666666667%" %}
{% code expandable="true" %}

```html
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flappy Bird</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            background: #222;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            font-family: 'Segoe UI', sans-serif;
            overflow: hidden;
            touch-action: none;
        }
        
        #game-container {
            position: relative;
            width: 400px;
            height: 600px;
            background: linear-gradient(to bottom, #70c5ce 0%, #70c5ce 80%, #c23810 80%, #c23810 100%);
            box-shadow: 0 0 20px rgba(0,0,0,0.5);
            overflow: hidden;
        }
        
        canvas {
            display: block;
        }
        
        .overlay {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            text-align: center;
            color: white;
            text-shadow: 2px 2px 0 #000;
            font-weight: bold;
            pointer-events: none;
        }
        
        .game-title {
            font-size: 48px;
            margin-bottom: 20px;
        }
        
        .score-display {
            font-size: 36px;
            margin-bottom: 10px;
        }
        
        .best-score {
            font-size: 24px;
            color: #ffe;
        }
        
        .instruction {
            font-size: 20px;
            animation: pulse 1s infinite;
        }
        
        @keyframes pulse {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; }
        }
        
        .hidden { display: none; }
    </style>
</head>
<body>
    <div id="game-container">
        <canvas id="canvas" width="400" height="600"></canvas>
        
        <!-- Startbildschirm -->
        <div id="start-screen" class="overlay">
            <div class="game-title">FLAPPY BIRD</div>
            <div class="instruction">Klicken oder Leertaste zum Fliegen</div>
        </div>
        
        <!-- Game-Over-Bildschirm -->
        <div id="game-over-screen" class="overlay hidden">
            <div class="game-title">SPIEL VORBEI</div>
            <div class="score-display">Punktestand: <span id="final-score">0</span></div>
            <div class="best-score">Bestwert: <span id="best-score">0</span></div>
            <div class="instruction">Zum Neustart klicken</div>
        </div>
        
        <!-- Punktezähler -->
        <div id="current-score" class="overlay hidden" style="top: 10%; font-size: 72px; color: white; text-shadow: 4px 4px 0 #000;">
            0
        </div>
    </div>

    <script>
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        
        // Spielkonstanten
        const GRAVITY = 0.4;
        const JUMP_STRENGTH = -7;
        const PIPE_SPEED = 3;
        const PIPE_SPAWN_RATE = 120; // Frames
        const PIPE_GAP = 120;
        
        // Spielzustand
        let bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
        let pipes = [];
        let score = 0;
        let bestScore = localStorage.getItem('flappyBest') || 0;
        let frameCount = 0;
        let isGameOver = false;
        let isPlaying = false;
        
        // DOM-Elemente
        const startScreen = document.getElementById('start-screen');
        const gameOverScreen = document.getElementById('game-over-screen');
        const currentScoreDisplay = document.getElementById('current-score');
        const finalScoreEl = document.getElementById('final-score');
        const bestScoreEl = document.getElementById('best-score');
        
        // Eingabeverarbeitung
        function handleInput(e) {
            if (!isPlaying) {
                if (isGameOver) {
                    resetGame();
                }
                startGame();
            } else if (!isGameOver) {
                bird.velocity = JUMP_STRENGTH;
                bird.wingState = 1;
            }
        }
        
        document.addEventListener('keydown', (e) => {
            if (e.code === 'Space' || e.code === 'ArrowUp') handleInput(e);
        });
        canvas.addEventListener('pointerdown', handleInput);
        
        function startGame() {
            isPlaying = true;
            isGameOver = false;
            startScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function resetGameState() {
            bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
            pipes = [];
            score = 0;
            frameCount = 0;
            currentScoreDisplay.textContent = score;
        }
        
        function resetGame() {
            isGameOver = false;
            isPlaying = true;
            gameOverScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function spawnPipe() {
            const minHeight = 100;
            const maxHeight = 400;
            const topHeight = Math.floor(Math.random() * (maxHeight - minHeight + 1) + minHeight);
            const bottomHeight = canvas.height - topHeight - PIPE_GAP;
            
            pipes.push({
                x: canvas.width,
                topHeight: topHeight,
                bottomY: topHeight + PIPE_GAP,
                bottomHeight: bottomHeight,
                passed: false
            });
        }
        
        function update() {
            if (isGameOver) return;
            
            // Physik des Vogels
            bird.velocity += GRAVITY;
            bird.y += bird.velocity;
            
            // Kollision mit Boden/Decke
            if (bird.y + bird.radius > canvas.height || bird.y - bird.radius < 0) {
                gameOver();
                return;
            }
            
            // Rohr-Generierung
            frameCount++;
            if (frameCount % PIPE_SPAWN_RATE === 0) {
                spawnPipe();
            }
            
            // Rohrbewegung und Kollision
            for (let i = pipes.length - 1; i >= 0; i--) {
                const pipe = pipes[i];
                pipe.x -= PIPE_SPEED;
                
                // Rohre außerhalb des Bildschirms entfernen
                if (pipe.x + 60 < 0) {
                    pipes.splice(i, 1);
                    continue;
                }
                
                // Kollisionsprüfung (vereinfachtes Rechteck-Kreis-Modell)
                const pipeWidth = 60;
                const pipeX = pipe.x;
                const pipeLeft = pipeX;
                const pipeRight = pipeX + pipeWidth;
                
                // Vogel ist ein Kreis, Rohre sind Rechtecke
                const birdLeft = bird.x - bird.radius + 4; // +4 für Schnabelversatz
                const birdRight = bird.x + bird.radius + 2;
                const birdTop = bird.y - bird.radius;
                const birdBottom = bird.y + bird.radius;
                
                // Horizontale Kollision prüfen
                if (birdRight > pipeLeft && birdLeft < pipeRight) {
                    // Kollision mit oberem Rohr
                    if (birdTop < pipe.topHeight) {
                        gameOver();
                        return;
                    }
                    // Kollision mit unterem Rohr
                    if (birdBottom > pipe.bottomY) {
                        gameOver();
                        return;
                    }
                }
                
                // Punkte zählen
                if (pipe.x + pipeWidth < bird.x && !pipe.passued) {
                    pipe.passed = true;
                    score++;
                    currentScoreDisplay.textContent = score;
                }
            }
            
            // Flügel animieren
            if (bird.wingState > 0) {
                bird.wingState = (bird.wingState + 0.2) % 2;
            }
        }
        
        function draw() {
            // Canvas leeren
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // Rohre zeichnen
            pipes.forEach(pipe => {
                // Oberes Rohr
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, 0, 60, pipe.topHeight);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.topHeight - 20, 60, 20); // Kappe
                
                // Unteres Rohr
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, pipe.bottomY, 60, canvas.height - pipe.bottomY);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.bottomY - 20, 60, 20); // Kappe
            });
            
            // Vogel zeichnen (Kreis mit Schnabel)
            ctx.fillStyle = '#e3bc4e';
            ctx.beginPath();
            ctx.arc(bird.x, bird.y, bird.radius, 0, Math.PI * 2);
            ctx.fill();
            
            // Schnabel
            ctx.fillStyle = '#e04c4c';
            ctx.beginPath();
            ctx.moveTo(bird.x + bird.radius - 4, bird.y - 4);
            ctx.lineTo(bird.x + bird.radius + 10, bird.y);
            ctx.lineTo(bird.x + bird.radius - 4, bird.y + 4);
            ctx.fill();
            
            // Augen
            ctx.fillStyle = 'black';
            ctx.beginPath();
            ctx.arc(bird.x + 5, bird.y - 6, 3, 0, Math.PI * 2);
            ctx.fill();
            
            // Flügel
            ctx.fillStyle = '#c4a';
            ctx.beginPath();
            ctx.ellipse(bird.x - 5, bird.y + 5, 10, 6, 0, 0, Math.PI * 2);
            ctx.fill();
        }
        
        function gameOver() {
            isGameOver = true;
            isPlaying = false;
            
            // Besten Punktestand aktualisieren
            if (score > bestScore) {
                bestScore = score;
                localStorage.setItem('flappyBest', bestScore);
            }
            
            // Game-Over-Bildschirm anzeigen
            currentScoreDisplay.classList.add('hidden');
            gameOverScreen.classList.remove('hidden');
            finalScoreEl.textContent = score;
            bestScoreEl.textContent = bestScore;
        }
        
        function gameLoop() {
            if (!isPlaying) return;
            
            update();
            draw();
            requestAnimationFrame(gameLoop);
        }
        
        // Erste Zeichnung
        draw();
    </script>
</body>
</html>
```

{% endcode %}
{% endcolumn %}
{% endcolumns %}

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

{% hint style="success" %}
Die Verwendung von `--kv-unified` kann die Inferenzbereitstellung in llama.cpp schneller machen! Siehe <https://www.reddit.com/r/LocalLLaMA/comments/1qnwa33/glm_47_flash_huge_performance_improvement_with_kvu/>
{% endhint %}

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_SET_ROWS=1 ./llama.cpp/llama-server \
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \
    --special \
    --alias "unsloth/Kimi-K2.5" \
    --min-p 0,01 \
    --ctx-size 16384 \
    --port 8001 \
    --kv-unified
```

{% endcode %}

Verwenden Sie anschließend die Python-Bibliothek von OpenAI nach `pip install openai` :

```python
from openai import OpenAI
import json
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.5",
    messages = [{"role": "user", "content": "Was ist 1+1?"},],
)
print(completion.choices[0].message.content)
```

Und wir erhalten:

<figure><img src="/files/5c7c3f2827d2ab2433720a1f8d7b1988a4a33767" alt="" width="563"><figcaption></figcaption></figure>

Und im anderen llama-server-Fenster:

<figure><img src="/files/bb1c4e56dfe90bb4590e08d45fa50f2b9de0e362" alt="" width="563"><figcaption></figcaption></figure>

### 📊 Benchmarks

Du kannst weiter unten Benchmarks in Tabellenform ansehen:

<figure><img src="/files/d1db0c840062438d6ade579df69b6b066c0d7d3d" alt="" width="375"><figcaption></figcaption></figure>

#### Reasoning & Knowledge

| Benchmark            | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| -------------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| HLE-Full             |      30.1 |    34.5 |            30.8 |         37.5 |         25,1† |                           - |
| HLE-Full (mit Tools) |      50.2 |    45.5 |            43.2 |         45.8 |         40,8† |                           - |
| AIME 2025            |      96.1 |     100 |            92.8 |         95.0 |          93.1 |                           - |
| HMMT 2025 (Feb)      |      95.4 |    99.4 |          92.9\* |       97.3\* |          92.5 |                           - |
| IMO-AnswerBench      |      81.8 |    86.3 |          78.5\* |       83.1\* |          78.3 |                           - |
| GPQA-Diamond         |      87.6 |    92.4 |            87.0 |         91.9 |          82.4 |                           - |
| MMLU-Pro             |      87.1 |  86.7\* |          89.3\* |         90.1 |          85.0 |                           - |

#### Bild & Video

| Benchmark             | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| --------------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| MMMU-Pro              |      78.5 |  79.5\* |            74.0 |         81.0 |             - |                        69.3 |
| CharXiv (RQ)          |      77.5 |    82.1 |          67.2\* |         81.4 |             - |                        66.1 |
| MathVision            |      84.2 |    83.0 |          77.1\* |       86.1\* |             - |                        74.6 |
| MathVista (mini)      |      90.1 |  82.8\* |          80.2\* |       89.8\* |             - |                        85.8 |
| ZeroBench             |         9 |     9\* |             3\* |          8\* |             - |                         4\* |
| ZeroBench (mit Tools) |        11 |     7\* |             9\* |         12\* |             - |                         3\* |
| OCRBench              |      92.3 |  80.7\* |          86.5\* |       90.3\* |             - |                        87.5 |
| OmniDocBench 1.5      |      88.8 |    85.7 |          87.7\* |         88.5 |             - |                      82.0\* |
| InfoVQA (val)         |      92.6 |    84\* |          76.9\* |       57.2\* |             - |                        89.5 |
| SimpleVQA             |      71.2 |  55.8\* |          69.7\* |       69.7\* |             - |                      56.8\* |
| WorldVQA              |      46.3 |    28.0 |            36.8 |         47.4 |             - |                        23.5 |
| VideoMMMU             |      86.6 |    85.9 |          84.4\* |         87.6 |             - |                        80.0 |
| MMVU                  |      80.4 |  80.8\* |            77.3 |         77.5 |             - |                        71.1 |
| MotionBench           |      70.4 |    64.8 |            60.3 |         70.3 |             - |                           - |
| VideoMME              |      87.4 |  86.0\* |               - |       88.4\* |             - |                        79.0 |
| LongVideoBench        |      79.8 |  76.5\* |          67.2\* |       77.7\* |             - |                      65.6\* |
| LVBench               |      75.9 |       - |               - |       73.5\* |             - |                        63.6 |

#### Coding

| Benchmark              | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| ---------------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| SWE-Bench Verified     |      76.8 |    80.0 |            80.9 |         76.2 |          73.1 |                           - |
| SWE-Bench Pro          |      50.7 |    55.6 |          55.4\* |            - |             - |                           - |
| SWE-Bench Multilingual |      73.0 |    72.0 |            77.5 |         65.0 |          70.2 |                           - |
| Terminal Bench 2.0     |      50.8 |    54.0 |            59.3 |         54.2 |          46.4 |                           - |
| PaperBench             |      63.5 |  63.7\* |          72.9\* |            - |          47.1 |                           - |
| CyberGym               |      41.3 |       - |            50.6 |       39.9\* |        17.3\* |                           - |
| SciCode                |      48.7 |    52.1 |            49.5 |         56.1 |          38.9 |                           - |
| OJBench (cpp)          |      57.4 |       - |          54.6\* |       68.5\* |        54.7\* |                           - |
| LiveCodeBench (v6)     |      85.0 |       - |          82.2\* |       87.4\* |          83.3 |                           - |

#### Langer Kontext

| Benchmark    | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| ------------ | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| Longbench v2 |      61.0 |  54.5\* |          64.4\* |       68.2\* |        59.8\* |                           - |
| AA-LCR       |      70.0 |  72.3\* |          71.3\* |       65.3\* |        64.3\* |                           - |

#### Agentische Suche

| Benchmark                          | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| ---------------------------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| BrowseComp                         |      60.6 |    65.8 |            37.0 |         37.8 |          51.4 |                           - |
| BrowseComp (mit Kontextverwaltung) |      74.9 |    65.8 |            57.8 |         59.2 |          67.6 |                           - |
| BrowseComp (Agent Swarm)           |      78.4 |       - |               - |            - |             - |                           - |
| WideSearch (item-f1)               |      72.7 |       - |          76.2\* |         57.0 |        32.5\* |                           - |
| WideSearch (item-f1 Agent Swarm)   |      79.0 |       - |               - |            - |             - |                           - |
| DeepSearchQA                       |      77.1 |  71.3\* |          76.1\* |       63.2\* |        60.9\* |                           - |
| FinSearchCompT2\&T3                |      67.8 |       - |          66.2\* |         49.9 |        59.1\* |                           - |
| Seal-0                             |      57.4 |    45.0 |          47.7\* |       45.5\* |        49.5\* |                           - |

#### Hinweise

* `*` = vom Autor neu bewertete Punktzahl (zuvor nicht öffentlich verfügbar).
* `†` = Die Punktzahl von DeepSeek V3.2 bezieht sich auf dessen Nur-Text-Untermenge (wie in den Fußnoten angegeben).
* `-` = nicht bewertet / nicht verfügbar.


---

# 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.5.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.