# Qwen3-Coder-Next: So führst du es lokal aus

Qwen veröffentlicht Qwen3-Coder-Next, ein 80B-MoE-Modell (3B aktive Parameter) mit **256K Kontext** für schnelles agentisches Coden und lokale Nutzung. Es ist in seiner Leistung mit Modellen vergleichbar, die 10–20× mehr aktive Parameter haben.

Es läuft mit **46 GB RAM**/VRAM/vereinheitlichtem Speicher (85 GB für 8-Bit) und ist non-reasoning für extrem schnelle Code-Antworten. Das Modell glänzt bei langem Schlussfolgern, komplexer Werkzeugnutzung und der Wiederherstellung nach Ausführungsfehlern.

{% hint style="success" %}
**Update vom 19. Feb.**: Tool-Aufrufe sollten jetzt noch besser sein, nachdem llama.cpp das Parsen behoben hat.

**NEU!** Siehe [Quantisierungs-Benchmarks](#gguf-quantization-benchmarks) für unsere Dynamic-GGUFs!

**4. Feb.:** `llama.cpp` einen Fehler behoben, der die Berechnung für `vektorisiertes key_gdiff korrigierte.` Dies behebt frühere Probleme mit Schleifen und Ausgaben. Wir haben die GGUFs aktualisiert – bitte **erneut herunterladen** und **UPDATE** `llama.cpp` für bessere Ausgaben.
{% endhint %}

Du erfährst außerdem, wie du das Modell auf Codex & Claude Code ausführst. Für **Fine-Tuning**passt Qwen3-Next-Coder in Unsloth auf eine einzelne B200-GPU für bf16-LoRA.

Qwen3-Coder-Next Unsloth [Dynamic GGUFs](https://unsloth.ai/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs) auszuführen: [unsloth/Qwen3-Coder-Next-GGUF](https://huggingface.co/unsloth/Qwen3-Coder-Next-GGUF)

<a href="#run-qwen3-coder-next" class="button primary">GGUF-Tutorial ausführen</a><a href="#improving-generation-speed" class="button secondary">Codex & Claude Code</a><a href="#fp8-qwen3-coder-next-in-vllm" class="button secondary">FP8-vLLM-Tutorial</a>

### ⚙️ Nutzungshandbuch

Hast du keine 46 GB RAM oder keinen vereinheitlichten Speicher? Kein Problem, du kannst unsere kleineren Quants wie 3-Bit ausführen. Am besten ist es, wenn die Modellgröße = der Summe deiner Rechenressourcen ( **`Festplattenspeicher + RAM + VRAM ≥ Größe des Quants).`** Wenn dein Quant vollständig auf dein Gerät passt, kannst du mit 20+ Token/s rechnen. Wenn er nicht passt, funktioniert es trotzdem per Auslagerung, aber es wird langsamer sein.

Um optimale Leistung zu erreichen, empfiehlt Qwen diese Einstellungen:

* <mark style="background-color:blue;">`Temperatur = 1.0`</mark>
* `Top_P = 0,95`
* `Top_K = 40`
* `Min_P = 0.01` (llama.cpps Standardwert ist 0.05)
* `Wiederholungsstrafe` = deaktiviert oder 1.0

Unterstützt nativ bis zu `262,144` Kontext, aber du kannst es auf `32,768` Tokens für geringeren Speicherverbrauch setzen.

### 🖥️ Qwen3-Coder-Next ausführen

Je nach Anwendungsfall musst du unterschiedliche Einstellungen verwenden. Da dieser Leitfaden 4-Bit nutzt, benötigst du etwa 46 GB RAM/vereinheitlichten Speicher. Wir empfehlen, mindestens 3-Bit-Präzision für die beste Leistung zu verwenden.

#### 🦥 Unsloth Studio-Anleitung

Qwen3-Coder-Next kann in [Unsloth Studio](https://unsloth.ai/docs/de/neu/studio), unserer neuen Open-Source-Web-UI für lokale KI. Mit Unsloth Studio kannst du Modelle lokal ausführen auf **MacOS, Windows**, Linux und:

{% columns %}
{% column %}

* Suchen, herunterladen, [GGUFs ausführen](https://unsloth.ai/docs/de/neu/studio#run-models-locally) und Safetensor-Modelle
* [**Selbstheilende** Tool-Calling](https://unsloth.ai/docs/de/neu/studio#execute-code--heal-tool-calling) + **Websuche**
* [**Code-Ausführung**](https://unsloth.ai/docs/de/neu/studio#run-models-locally) (Python, Bash)
* [Automatische Inferenz](https://unsloth.ai/docs/de/neu/studio#model-arena) Parameter-Tuning (Temp, Top-p usw.)
* Schnelle CPU- + GPU-Inferenz via llama.cpp
* [LLMs trainieren](https://unsloth.ai/docs/de/neu/studio#no-code-training) 2x schneller mit 70 % weniger VRAM
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FFeQ0UUlnjXkDdqhcWglh%2Fskinny%20studio%20chat.png?alt=media&#x26;token=c2ee045f-c243-4024-a8e4-bb4dbe7bae79" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

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

In deinem Terminal ausführen:

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 ca. 1–2 Minuten.**
{% endhint %}
{% endstep %}

{% step %}
**Unsloth starten**

MacOS, Linux, WSL und Windows:

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

Dann öffne `http://localhost:8888` in deinem Browser.
{% endstep %}

{% step %}
**Qwen3-Coder-Next 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, in dem du ein Modell, einen Datensatz und grundlegende Einstellungen auswählst. Du kannst ihn jederzeit überspringen und direkt zum Chat gehen.

Gehe dann zum [Studio Chat](https://unsloth.ai/docs/de/neu/studio/chat) Registerkarte und suche nach **Qwen3-Coder-Next** in der Suchleiste und lade dein gewünschtes Modell und Quant herunter.

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fit06amlW1KexxlYARKNV%2FScreenshot%202026-04-02%20at%201.57.55%E2%80%AFAM.png?alt=media&#x26;token=74fb6c0f-fbd1-4506-be76-050f27de8d02" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}
**Qwen3-Coder-Next ausführen**

Inferenzparameter sollten in Unsloth Studio automatisch gesetzt werden, du kannst sie jedoch weiterhin manuell ändern. Du kannst auch die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten.

Für weitere Informationen kannst du unseren [Unsloth Studio Inferenz-Leitfaden](https://unsloth.ai/docs/de/neu/studio/chat).

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FXPQGEEr1YoKofrTatAKK%2Ftoolcallingif.gif?alt=media&#x26;token=25d68698-fb13-4c46-99b2-d39fb025df08" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

#### Llama.cpp-Tutorial (GGUF):

Anweisungen zum Ausführen in llama.cpp (beachten Sie, dass wir 4-Bit verwenden werden, um auf die meisten Geräte zu passen):

{% stepper %}
{% step %}
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 fahre wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert.

{% code overflow="wrap" %}

```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
```

{% endcode %}
{% endstep %}

{% step %}
Du kannst direkt von Hugging Face ziehen. Du kannst den Kontext auf 256K erhöhen, wenn dein RAM/VRAM dafür ausreicht. Mit `--fit auf` wird die Kontextlänge ebenfalls automatisch bestimmt.

Du kannst die empfohlenen Parameter verwenden: `temperature=1.0`, `top_p=0.95`, `top_k=40`

```bash
./llama.cpp/llama-cli \
    -hf unsloth/Qwen3-Coder-Next-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \
    --temp 1.0 --top-p 0.95 --min-p 0.01 --top-k 40
```

{% endstep %}

{% step %}
Lade das Modell herunter über (nach der Installation von `pip install huggingface_hub`). Du kannst `UD-Q4_K_XL` oder andere quantisierte Versionen. Wenn Downloads hängen bleiben, siehe [hugging-face-hub-xet-debugging](https://unsloth.ai/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging "mention")

{% code overflow="wrap" %}

```bash
pip install -U huggingface_hub
hf download unsloth/Qwen3-Coder-Next-GGUF \\
    --local-dir unsloth/Qwen3-Coder-Next-GGUF \\
    --include "*UD-Q4_K_XL*"
```

{% endcode %}
{% endstep %}

{% step %}
Dann führe das Modell im Konversationsmodus aus:

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/Qwen3-Coder-Next-GGUF/Qwen3-Coder-Next-UD-Q4_K_XL.gguf \\
    --seed 3407 \\
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.01 \\
    --top-k 40
```

{% endcode %}

Passen Sie außerdem das **Kontextfenster** wie erforderlich, bis zu `262,144`

{% hint style="info" %}
HINWEIS: Dieses Modell unterstützt nur den Non-Thinking-Modus und erzeugt keine `<think></think>` Blöcke in seiner Ausgabe. Daher ist das Angeben von `enable_thinking=False` nicht mehr erforderlich.
{% endhint %}
{% endstep %}
{% endstepper %}

### 🦙Llama-Server-Bereitstellung & Deployment

Um Qwen3-Coder-Next für den produktiven Einsatz bereitzustellen, verwenden wir `llama-server` in einem neuen Terminal, z. B. via tmux. Stelle dann das Modell bereit via:

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-server \
    --model unsloth/Qwen3-Coder-Next-GGUF/Qwen3-Coder-Next-UD-Q4_K_XL.gguf \\
    --alias "unsloth/Qwen3-Coder-Next" \\
    --seed 3407 \\
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.01 \\
    --top-k 40 \\
    --port 8001 \
```

{% endcode %}

Dann in einem neuen Terminal, nachdem du `pip install openai`, können wir das Modell ausführen:

{% code overflow="wrap" %}

```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/Qwen3-Coder-Next",
    messages = [{"role": "user", "content": "Erstelle ein Flappy-Bird-Spiel in HTML"},],
)
print(completion.choices[0].message.content)
```

{% endcode %}

Das wird Folgendes ausgeben:

{% columns %}
{% column width="66.66666666666666%" %}
{% code overflow="wrap" expandable="true" %}

````markdown
Hier ist ein vollständiges, funktionierendes Flappy-Bird-Spiel, das in einer einzigen Datei enthalten ist.

Ich habe **HTML5 Canvas** für die Grafik und **JavaScript** für die Physik verwendet (Schwerkraft, Kollisionserkennung und Punktestand). Es sind keine externen Bilder oder Downloads erforderlich; das Spiel zeichnet den Vogel und die Rohre per Code.

### So führst du es aus:
1.  Kopiere den untenstehenden Codeblock.
2.  Erstelle auf deinem Computer eine neue Datei mit dem Namen `game.html`.
3.  Füge den Code in diese Datei ein und speichere sie.
4.  Doppelklicke auf `game.html`, um es in deinem Webbrowser zu öffnen.

```html
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Einfaches Flappy Bird</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            height: 100vh;
            background-color: #333;
            font-family: 'Courier New', Courier, monospace;
            color: white;
        }

        h1 {
            margin-bottom: 10px;
        }

        #game-container {
            position: relative;
            box-shadow: 0 0 20px rgba(0,0,0,0.5);
        }

        canvas {
            display: block;
            background-color: #70c5ce; /* Himmelblau */
            border: 4px solid #000;
        }

        #ui-layer {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none; /* Klicks zum Canvas durchlassen */
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            text-align: center;
        }

        .message {
            background: rgba(255, 255, 255, 0.8);
            padding: 20px;
            border-radius: 10px;
            color: #333;
        }

        #score-board {
            position: absolute;
            top: 20px;
            width: 100%;
            text-align: center;
            font-size: 40px;
            font-weight: bold;
            color: white;
            text-shadow: 2px 2px 0 #000;
            z-index: 10;
        }
    </style>
</head>
<body>

    <h1>Flappy-Bird-Klon</h1>
    
    <div id="game-container">
        <div id="score-board">0</div>
        <canvas id="birdCanvas" width="320" height="480"></canvas>
        
        <div id="ui-layer">
            <div id="start-screen" class="message">
                <h2>Bereit zum Fliegen?</h2>
                <p>Drücke <strong>Leertaste</strong> oder <strong>Klicke</strong>, um zu springen</p>
                <p>Drücke die Leertaste, um zu starten</p>
            </div>
            <div id="game-over-screen" class="message" style="display: none;">
                <h2>Spiel beendet</h2>
                <p>Punktestand: <span id="final-score">0</span></p>
                <p>Bester Wert: <span id="best-score">0</span></p>
                <p>Drücke <strong>Leertaste</strong>, um neu zu starten</p>
            </div>
        </div>
    </div>

    <script>
        // --- Konfiguration ---
        const canvas = document.getElementById('birdCanvas');
        const ctx = canvas.getContext('2d');
        const scoreElement = document.getElementById('score-board');
        const startScreen = document.getElementById('start-screen');
        const gameOverScreen = document.getElementById('game-over-screen');
        const finalScoreSpan = document.getElementById('final-score');
        const bestScoreSpan = document.getElementById('best-score');

        // Spielvariablen
        let frames = 0;
        let score = 0;
        let highScore = localStorage.getItem('flappyHighScore') || 0;
        let gameState = 'START'; // START, PLAYING, GAMEOVER
        const gravity = 0.25;
        const speed = 2; // Geschwindigkeit der Rohre nach links

        // --- Das Vogel-Objekt ---
        const bird = {
            x: 50,
            y: 150,
            width: 30,
            height: 30,
            velocity: 0,
            jumpStrength: 4.5,
            radius: 15,
            draw: function() {
                ctx.fillStyle = "#FFD700"; // Goldene Farbe
                ctx.beginPath();
                ctx.arc(this.x + this.radius, this.y + this.radius, this.radius, 0, Math.PI * 2);
                ctx.fill();
                ctx.lineWidth = 2;
                ctx.stroke();

                // Auge
                ctx.fillStyle = "white";
                ctx.beginPath();
                ctx.arc(this.x + this.radius + 5, this.y + this.radius - 5, 5, 0, Math.PI * 2);
                ctx.fill();
                ctx.fillStyle = "black";
                ctx.beginPath();
                ctx.arc(this.x + this.radius + 7, this.y + this.radius - 5, 2, 0, Math.PI * 2);
                ctx.fill();
                
                // Schnabel
                ctx.fillStyle = "orange";
                ctx.beginPath();
                ctx.moveTo(this.x + this.radius + 10, this.y + this.radius);
                ctx.lineTo(this.x + this.radius + 20, this.y + this.radius + 5);
                ctx.lineTo(this.x + this.radius + 10, this.y + this.radius + 10);
                ctx.fill();
                ctx.stroke();
            },
            update: function() {
                this.velocity += gravity;
                this.y += this.velocity;

                // Boden-Kollision
                if (this.y + this.height >= canvas.height) {
                    this.y = canvas.height - this.height;
                    gameOver();
                }
                
                // Kollision mit der Decke (optional: verhindert das Überfliegen der Rohre)
                if (this.y < 0) {
                    this.y = 0;
                    this.velocity = 0;
                }
            },
            jump: function() {
                this.velocity = -this.jumpStrength;
            },
            reset: function() {
                this.y = 150;
                this.velocity = 0;
            }
        };

        // --- Das Rohre-Array ---
        const pipes = {
            position: [],
            width: 50,
            gap: 120, // Abstand zwischen oberem und unterem Rohr
            dx: 2, // Bewegungsgeschwindigkeit

            draw: function() {
                for (let i = 0; i < this.position.length; i++) {
                    let p = this.position[i];
                    let topY = p.y;
                    let bottomY = p.y + this.gap;

                    ctx.fillStyle = "#228B22"; // Waldgrün

                    // Oberes Rohr
                    ctx.fillRect(p.x, 0, this.width, topY);
                    ctx.strokeRect(p.x, 0, this.width, topY);

                    // Unteres Rohr
                    ctx.fillRect(p.x, bottomY, this.width, canvas.height - bottomY);
                    ctx.strokeRect(p.x, bottomY, this.width, canvas.height - bottomY);
                }
            },

            update: function() {
                // Alle 120 Frames ein neues Rohr hinzufügen (ca. 2 Sekunden)
                if (frames % 120 === 0) {
                    // Zufällige Höhe für das obere Rohr
                    // Mindesthöhe 50, Maximalhöhe canvas - gap - 50
                    let maxY = canvas.height - this.gap - 50;
                    let randomY = Math.floor(Math.random() * (maxY - 50 + 1) + 50);
                    
                    this.position.push({
                        x: canvas.width,
                        y: randomY
                    });
                }

                for (let i = 0; i < this.position.length; i++) {
                    let p = this.position[i];
                    p.x -= this.dx;

                    // Kollisions­erkennung
                    // Logik: Prüfe, ob sich die Vogel-X-Position im X-Bereich des Rohrs befindet
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // Logik: Prüfe, ob die Vogel-Y-Position das obere ODER untere Rohr trifft
                        if (bird.y < p.y || bird.y + bird.height > p.y + this.gap) {
                            gameOver();
                        }
                    }

                    // Punktestand aktualisieren (wenn der Vogel am Rohr vorbeikommt)
                    if (p.x + this.width < bird.x && !p.passed) {
                        score++;
                        scoreElement.innerText = score;
                        p.passed = true;
                    }

                    // Rohre entfernen, die aus dem Bildschirm gelaufen sind
                    if (p.x + this.width <= 0) {
                        this.position.shift();
                        // i dekrementieren, weil sich die Array-Länge geändert hat
                        i--; 
                    }
                }
            },
            
            reset: function() {
                this.position = [];
            }
        };

        // --- Hintergrund (Wolken/Gras) ---
        const background = {
            draw: function() {
                // Gras zeichnen
                ctx.fillStyle = "#7cfc00"; // Rasen-Grün
                ctx.fillRect(0, canvas.height - 20, canvas.width, 20);
                ctx.beginPath();
                ctx.moveTo(0, canvas.height - 20);
                ctx.lineTo(canvas.width, canvas.height - 20);
                ctx.stroke();
            }
        };

        // --- Spielsteuerungsfunktionen ---

        function loop() {
            // Canvas löschen
            ctx.clearRect(0, 0, canvas.width, canvas.height);

            // Hintergrund zeichnen
            background.draw();

            if (gameState === 'START') {
                bird.draw();
                // Eine Bodenlinie zeichnen
                ctx.fillStyle = "#ded895";
                ctx.fillRect(0, canvas.height - 10, canvas.width, 10);
            } 
            else if (gameState === 'PLAYING') {
                bird.update();
                bird.draw();
                pipes.update();
                pipes.draw();
                frames++;
            } 
            else if (gameState === 'GAMEOVER') {
                pipes.draw();
                bird.draw();
                // Frames oder Position nicht aktualisieren, einfach einfrieren
            }

            requestAnimationFrame(loop);
        }

        function startGame() {
            gameState = 'PLAYING';
            startScreen.style.display = 'none';
            gameOverScreen.style.display = 'none';
            score = 0;
            frames = 0;
            scoreElement.innerText = score;
            bird.reset();
            pipes.reset();
        }

        function gameOver() {
            gameState = 'GAMEOVER';
            
            // Highscore aktualisieren
            if (score > highScore) {
                highScore = score;
                localStorage.setItem('flappyHighScore', highScore);
            }

            finalScoreSpan.innerText = score;
            bestScoreSpan.innerText = highScore;
            gameOverScreen.style.display = 'block';
        }

        // --- Eingabebehandlung ---

        function handleInput(e) {
            // Standard-Scrollverhalten für die Leertaste verhindern
            if (e.type === 'keydown' && e.code === 'Space') {
                e.preventDefault();
            }

            if (e.code === 'Space' || e.type === 'mousedown' || e.type === 'touchstart') {
                switch (gameState) {
                    case 'START':
                        startGame();
                        bird.jump();
                        break;
                    case 'PLAYING':
                        bird.jump();
                        break;
                    case 'GAMEOVER':
                        startGame();
                        bird.jump();
                        break;
                }
            }
        }

        window.addEventListener('keydown', handleInput);
        canvas.addEventListener('mousedown', handleInput);
        canvas.addEventListener('touchstart', handleInput);

        // Initialisieren
        loop();

    </script>
</body>
</html>
```

### Funktionen in dieser Version:
1.  **Physik:** Realistische Schwerkraft- und Sprungmechanik.
2.  **Kollisionserkennung:** Das Spiel endet, wenn du die Rohre, den Boden oder die Decke berührst.
3.  **Punktesystem:** Du erhältst 1 Punkt für jedes Rohr, an dem du vorbeikommst.
4.  **Highscore:** Verwendet den LocalStorage deines Browsers, um deinen besten Punktestand zu merken, selbst wenn du die Seite neu lädst.
5.  **Reaktionsschnelle Steuerung:** Funktioniert mit der **Leertaste**, einem **Mausklick** oder **Touch** (für mobile Geräte).
6.  **Grafik:** Der Vogel wird per Code gezeichnet (einschließlich Auge und Schnabel), und die Rohre haben Ränder, sodass keine defekten Bildlinks auftreten.
````

{% endcode %}

Wir haben das HTML extrahiert und ausgeführt, und das daraus erzeugte Beispiel-Flappy-Bird-Spiel funktionierte gut!
{% endcolumn %}

{% column width="33.33333333333334%" %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F7ATJWz7O4jMxpVI6I1Wk%2Fimage.png?alt=media&#x26;token=a81548fa-843b-499d-9db6-6f215ad5fb99" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

### 👾 OpenAI Codex & Claude Code <a href="#claude-codex" id="claude-codex"></a>

Um das Modell über lokale agentische Coding-Workloads auszuführen, kannst du [unserem Leitfaden folgen](https://unsloth.ai/docs/de/grundlagen/claude-code). Ändere einfach den Modellnamen '[GLM-4.7-Flash](https://unsloth.ai/docs/de/modelle/glm-4.7-flash)' zu 'Qwen3-Coder-Next' und stelle sicher, dass du die korrekten Parameter und Nutzungshinweise für Qwen3-Coder-Next befolgst. Verwende die `llama-server` das wir gerade eben eingerichtet haben.

{% columns %}
{% column %}
{% content-ref url="../grundlagen/claude-code" %}
[claude-code](https://unsloth.ai/docs/de/grundlagen/claude-code)
{% endcontent-ref %}
{% endcolumn %}

{% column %}
{% content-ref url="../grundlagen/codex" %}
[codex](https://unsloth.ai/docs/de/grundlagen/codex)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

Nachdem du beispielsweise die Anweisungen für Claude Code befolgt hast, wirst du sehen:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fup2DMSMPjNR8BM9pgR0v%2Fimage.png?alt=media&#x26;token=152e9ee0-2491-4379-af18-8fca0789b19d" alt="" width="563"><figcaption></figcaption></figure>

Dann können wir zum Beispiel fragen `Erstelle ein Python-Spiel für Schach` :

<div><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F9TfMAoKSdMpb8OHKNnHH%2Fimage.png?alt=media&#x26;token=771df3aa-91ab-4c1e-8676-1830058001ca" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FWP3lI5mQW2EHB79qqgDz%2Fimage.png?alt=media&#x26;token=55cf3189-e100-419c-a615-024b45948284" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fn8DZddDODQZGCP8giKYY%2Fimage.png?alt=media&#x26;token=996c8cb9-d199-4045-90f0-408690e02667" alt="" width="563"><figcaption></figcaption></figure></div>

Wenn du `API Error: 400 {"error":{"code":400,"message":"request (16582 tokens) exceeds the available context size (16384 tokens), try increasing it","type":"exceed_context_size_error","n_prompt_tokens":16582,"n_ctx":16384}}` siehst, bedeutet das, dass du die Kontextlänge erhöhen musst oder siehe [#how-to-fit-long-context-256k-to-1m](#how-to-fit-long-context-256k-to-1m "mention")

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FP6anV1XewSWIovaH3f7c%2Fimage.png?alt=media&#x26;token=285a540b-f6fc-4541-b807-bf4f6dc3807b" alt=""><figcaption></figcaption></figure>

### 🎱 FP8 Qwen3-Coder-Next in vLLM

Du kannst jetzt unsere neue [FP8 Dynamic-Quantisierung](https://huggingface.co/unsloth/Qwen3-Coder-Next-FP8-Dynamic) des Modells für erstklassige und schnelle Inferenz verwenden. Installiere zuerst vLLM aus dem Nightly-Build. Ändere `--extra-index-url https://wheels.vllm.ai/nightly/cu130` auf deine CUDA-Version, die du mit `nvidia-smi` ermittelt hast - nur `cu129` und `cu130` werden derzeit unterstützt.

{% hint style="success" %}
Wenn du vLLM / SGLang verwendest, versuche unsere FP8-Dynamic-Quants, die den Durchsatz um 25 % oder mehr steigern können! Siehe [#fp8-qwen3-coder-next-in-vllm](#fp8-qwen3-coder-next-in-vllm "mention")
{% endhint %}

{% code overflow="wrap" %}

```bash
# Installiere uv, wenn du es nicht hast, für schnellere Installationen der Umgebung
curl -LsSf https://astral.sh/uv/install.sh | sh

# Erstelle eine neue Python-Umgebung - nicht nötig, wenn du dein gesamtes System ändern möchtest
uv venv unsloth_fp8 --python 3.12 --seed
source unsloth_fp8/bin/activate

uv pip install --upgrade --force-reinstall vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly/cu130
uv pip install --upgrade --force-reinstall git+https://github.com/huggingface/transformers.git
uv pip install --force-reinstall numba
```

{% endcode %}

Dann bereitstellen [die dynamische FP8-Version von Unsloth](https://huggingface.co/unsloth/Qwen3-Coder-Next-FP8-Dynamic) des Modells. Du kannst FP8 auch aktivieren, um die KV-Cache-Speichernutzung um 50 % zu reduzieren, indem du `--kv-cache-dtype fp8` Wir haben es auf 4 GPUs bereitgestellt, aber wenn du 1 GPU hast, verwende `CUDA_VISIBLE_DEVICES='0'` und setze `--tensor-parallel-size 1` oder entferne dieses Argument. Verwende `tmux` um das Folgende in einem neuen Terminal zu starten und dann STRG+B+D - verwende `tmux attach-session -t0` um wieder dorthin zurückzukehren.

```bash
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
CUDA_VISIBLE_DEVICES='0,1,2,3' vllm serve unsloth/Qwen3-Coder-Next-FP8-Dynamic \\
    --served-model-name unsloth/Qwen3-Coder-Next \\
    --tensor-parallel-size 4 \\
    --tool-call-parser qwen3_coder \\
    --enable-auto-tool-choice \\
    --dtype bfloat16 \\
    --seed 3407 \\
    --max-model-len 200000 \\
    --gpu-memory-utilization 0.93 \\
    --port 8001
```

Du solltest etwas Ähnliches wie unten sehen. Siehe [#tool-calling-with-qwen3-coder-next](#tool-calling-with-qwen3-coder-next "mention") für Hinweise dazu, wie du Qwen3-Coder-Next tatsächlich mit der OpenAI-API und Tool-Calling verwendest – das funktioniert für vLLM und llama-server.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FxRdgnzg1gz3lBLPvftRx%2Fimage.png?alt=media&#x26;token=4f43796b-397f-4ffb-86d2-68afd14994f9" alt=""><figcaption></figcaption></figure>

### :wrench:Tool-Calling mit Qwen3-Coder-Next

In einem neuen Terminal erstellen wir einige Tools, wie das Addieren von 2 Zahlen, das Ausführen von Python-Code, das Ausführen von Linux-Funktionen und vieles mehr:

{% code expandable="true" %}

```python
import json, subprocess, random
from typing import Any
def add_number(a: float | str, b: float | str) -> float:
    return float(a) + float(b)
def multiply_number(a: float | str, b: float | str) -> float:
    return float(a) * float(b)
def substract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Vor langer, langer Zeit in einer weit, weit entfernten Galaxie...",
        "Es gab 2 Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil sich jedes Faultier zu übermenschlicher Intelligenz entwickelte...",
        "Ohne dass ein Freund es wusste, programmierte der andere versehentlich ein Programm, um Faultiere weiterzuentwickeln...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Kann die Befehle 'rm, sudo, dd, chmod' nicht ausführen, da sie gefährlich sind"
        print(msg); return msg
    print(f"Terminalbefehl wird ausgeführt `{command}`")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Befehl fehlgeschlagen: {e.stderr}"
def python(code: str) -> str:
    data = {}
    exec(code, data)
    del data["__builtins__"]
    return str(data)
MAP_FN = {
    "add_number": add_number,
    "multiply_number": multiply_number,
    "substract_number": substract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Addiere zwei Zahlen.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "Multipliziere zwei Zahlen.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "substract_number",
            "description": "Subtrahiere zwei Zahlen.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "Schreibt eine zufällige Geschichte.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Führe Operationen im Terminal aus.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "Der Befehl, den du ausführen möchtest, z. B. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Rufe einen Python-Interpreter mit etwas Python-Code auf, der ausgeführt wird.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Der auszuführende Python-Code",
                    },
                },
                "required": ["code"],
            },
        },
    },
]
```

{% endcode %}

Wir verwenden dann die folgenden Funktionen (kopieren, einfügen und ausführen), die die Funktionsaufrufe automatisch parsen und für jedes Modell den OpenAI-Endpunkt aufrufen:

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

```python
from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 1.0,
    top_p = 0.95,
    top_k = 40,
    min_p = 0.01,
    repetition_penalty = 1.0,
):
    messages = messages.copy()
    openai_client = OpenAI(
        base_url = "http://127.0.0.1:8001/v1",
        api_key = "sk-no-key-required",
    )
    model_name = next(iter(openai_client.models.list())).id
    print(f"Verwende Modell = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Aktuelle Nachrichten = {messages}")
        response = openai_client.chat.completions.create(
            model = model_name,
            messages = messages,
            temperature = temperature,
            top_p = top_p,
            tools = tools if tools else None,
            tool_choice = "auto" if tools else None,
            extra_body = {"top_k": top_k, "min_p": min_p, "repetition_penalty" :repetition_penalty,}
        )
        tool_calls = response.choices[0].message.tool_calls or []
        content = response.choices[0].message.content or ""
        tool_calls_dict = [tc.to_dict() for tc in tool_calls] if tool_calls else tool_calls
        messages.append({"role": "assistant", "tool_calls": tool_calls_dict, "content": content,})
        for tool_call in tool_calls:
            fx, args, _id = tool_call.function.name, tool_call.function.arguments, tool_call.id
            out = MAP_FN[fx](**json.loads(args))
            messages.append({"role": "tool", "tool_call_id": _id, "name": fx, "content": str(out),})
        else:
            has_tool_calls = False
    return messages
```

{% endcode %}

Im Folgenden zeigen wir mehrere Methoden, wie man Tool-Calling für viele verschiedene Anwendungsfälle ausführt:

#### Generierten Python-Code ausführen

{% code overflow="wrap" %}

```python
messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Erstelle eine Fibonacci-Funktion in Python und finde fib(20)."}],
}]
unsloth_inference(messages, temperature = 1.0, top_p = 0.95, top_k = 40, min_p = 0.00)
```

{% endcode %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F7fY3LSeNCjHXNjBwQkbI%2Fimage.png?alt=media&#x26;token=50eba62e-f8b2-424a-833b-be56696b4710" alt=""><figcaption></figcaption></figure>

#### Beliebige Terminalfunktionen ausführen

{% code overflow="wrap" %}

```python
messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Schreibe 'Ich bin ein glücklicher Sloth' in eine Datei und gib sie mir dann zurück aus."}],
}]
messages = unsloth_inference(messages, temperature = 1.0, top_p = 1.0, top_k = 40, min_p = 0.00)
```

{% endcode %}

Wir bestätigen, dass die Datei erstellt wurde, und das wurde sie!

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FabplwVbEMlsCEJTmxzSA%2Fimage.png?alt=media&#x26;token=eb27f30a-c91e-4aec-8fb0-f4a35921d3db" alt=""><figcaption></figcaption></figure>

Siehe [tool-calling-guide-for-local-llms](https://unsloth.ai/docs/de/grundlagen/tool-calling-guide-for-local-llms "mention") für weitere Beispiele für Tool-Calling.

## :triangular\_ruler:Benchmarks

### GGUF-Quantisierungs-Benchmarks

Hier sind einige Quantisierungs-Benchmarks, die von unabhängigen Prüfern durchgeführt wurden.

<div><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FAc5D3rcKmF6NjlyoLCXJ%2Fqwen3-coder-next-oddly-usable-at-aggressive-quantization-v0-q9q4nsw11rkg1.webp?alt=media&#x26;token=a92049ff-0bc2-4afa-a281-82bbacbfe42b" alt="" width="563"><figcaption><p>Aider Polyglot-Benchmarks</p></figcaption></figure> <figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Ftbfnqq8ppzwFbeqPhnw0%2FHAfMRrrXQAALkQb.png?alt=media&#x26;token=9730d4e1-3d4a-4ae6-92bf-32aa6724ab86" alt="" width="450"><figcaption><p>Benjamine-Marie-Benchmarks (<a href="https://x.com/bnjmn_marie/status/2019809651387514947/photo/1">Quelle</a>)</p></figcaption></figure></div>

{% columns %}
{% column %}
Die Benchmarks wurden von Drittbeiträgern auf dem Aider-Polyglot-Server ausgeführt und vergleichen Unsloth-GGUF-Quantisierungen im Aider-Polyglot-Benchmark (Score vs. VRAM). Bemerkenswert ist, dass das 3-Bit **`UD-IQ3_XXS`** Quant kommt nahe an **BF16** Leistung heran und macht **3-Bit ist ein sinnvoller Mindestwert** für die meisten Anwendungsfälle.

**NVFP4** schneidet geringfügig besser ab als die BF16-Referenz, was aufgrund der begrenzten Anzahl an Läufen Sampling-Rauschen sein kann; das Gesamtmuster für: **1-Bit → 2-Bit → 3-Bit → 6-Bit** das sich stetig verbessert, deutet darauf hin, dass der Benchmark aussagekräftige Qualitätsunterschiede zwischen den Unsloth GGUFs erfasst. Das **nicht-Unsloth** FP8 scheint schlechter abzuschneiden als sowohl **`UD-IQ3_XXS`** und **`UD-Q6_K_XL`**; das könnte Unterschiede in der Quantisierungspipeline widerspiegeln oder erneut auf unzureichendes Sampling hindeuten.
{% endcolumn %}

{% column %}
[Benjamin Marie (Drittanbieter) benchmarkte](https://x.com/bnjmn_marie/status/2019809651387514947/photo/1) **Qwen3-Coder-Next** unter Verwendung von Unsloth und Qwen GGUFs auf einem **750-Prompt-Mischsuite** (LiveCodeBench v6, MMLU Pro, GPQA, Math500) und berichtet sowohl **die Gesamtgenauigkeit** und **die relative Fehlerzunahme** (wie viel häufiger das quantisierte Modell im Vergleich zum Original Fehler macht).

Die Grafiken zeigen deutlich, dass Unsloths Q4\_K\_M-Quantisierungen besser abschneiden als standardmäßige Q4\_K\_M. Q3\_K\_M schneidet erwartungsgemäß bei Live Code Bench v6 schlechter ab, aber überraschenderweise bei HumanEval deutlich besser als standardmäßiges Q4\_K\_M.\
\
Es scheint mit der höchsten Effizienz zu laufen; mindestens Q4\_K\_M zu verwenden wird empfohlen.
{% endcolumn %}
{% endcolumns %}

### Qwen3-Coder-Next-Benchmarks

Qwen3-Coder-Next ist das leistungsstärkste Modell seiner Größe, und seine Leistung ist vergleichbar mit Modellen mit 10–20× mehr aktiven Parametern.

<table data-full-width="true"><thead><tr><th>Benchmark</th><th align="right">Qwen3-Coder-Next (80B)</th><th align="right">DeepSeek-V3.2 (671B)</th><th align="right">GLM-4.7 (358B)</th><th align="right">MiniMax M2.1 (229B)</th></tr></thead><tbody><tr><td>SWE-Bench Verified (mit SWE-Agent)</td><td align="right">70.6</td><td align="right">70.2</td><td align="right">74.2</td><td align="right">74.8</td></tr><tr><td>SWE-Bench Multilingual (mit SWE-Agent)</td><td align="right">62.8</td><td align="right">62.3</td><td align="right">63.7</td><td align="right">66.2</td></tr><tr><td>SWE-Bench Pro (mit SWE-Agent)</td><td align="right">44.3</td><td align="right">40.9</td><td align="right">40.6</td><td align="right">34.6</td></tr><tr><td>Terminal-Bench 2.0 (mit Terminus-2 JSON)</td><td align="right">36.2</td><td align="right">39.3</td><td align="right">37.1</td><td align="right">32.6</td></tr><tr><td>Aider</td><td align="right">66.2</td><td align="right">69.9</td><td align="right">52.1</td><td align="right">61.0</td></tr></tbody></table>

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F0M7glBoWyRQjHUgaVEev%2Fbenchmarks.png?alt=media&#x26;token=d215bbcb-358e-41c4-9f27-66df8d3d94d8" alt=""><figcaption></figcaption></figure>

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FKxPCUD7NhqHFwFcsmgfb%2Fswebench_pro.png?alt=media&#x26;token=eb895603-6176-43d4-aa4d-9d127ef61381" alt="" width="563"><figcaption></figcaption></figure>

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FxsChrrfjcNVTXN2R0ZRL%2Fqwencodermas.png?alt=media&#x26;token=081a28bb-003c-4c92-b086-e2bef1ab91c2" alt=""><figcaption></figcaption></figure>