> 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/qwen3-coder-next.md).

# Qwen3-Coder-Next: Lokal ausführen

Leitfaden zum Ausführen von Qwen3-Coder-Next lokal auf deinem Gerät!

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

Es läuft auf **46 GB RAM**/VRAM/einheitlichem Speicher (85 GB für 8-Bit) und ist non-reasoning für ultraschnelle Code-Antworten. Das Modell glänzt bei langfristigem Schlussfolgern, komplexer Tool-Nutzung und der Wiederherstellung nach Ausführungsfehlern.

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

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

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

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

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

<a href="/docs/de/modelle/qwen3-coder-next.md#run-qwen3-coder-next" class="button primary">GGUF-Tutorial ausführen</a><a href="https://unsloth.ai/docs/models/qwen3-coder-next#claude-codex" class="button secondary">Codex & Claude Code</a><a href="/docs/de/modelle/qwen3-coder-next.md#fp8-qwen3-coder-next-in-vllm" class="button secondary">FP8-vLLM-Tutorial</a>

### ⚙️ Gebrauchsanleitung

Hast du keine 46 GB RAM oder keinen einheitlichen Speicher? Keine Sorge, 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+ Tokens/s rechnen. Wenn es nicht passt, funktioniert es dank Offloading trotzdem, ist aber langsamer.

Um eine optimale Leistung zu erzielen, empfiehlt Qwen diese Einstellungen:

* <mark style="background-color:blue;">`Temperatur = 1,0`</mark>
* `Top_P = 0.95`
* `Top_K = 40`
* `Min_P = 0,01` (Der Standardwert von llama.cpp ist 0,05)
* `Wiederholungsstrafe` = deaktiviert oder 1,0

Unterstützt nativ bis zu `262,144` Kontext, aber Sie können es auf `32,768` Tokens für geringeren Speicherverbrauch.

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

Je nach Anwendungsfall musst du unterschiedliche Einstellungen verwenden. Da diese Anleitung 4-Bit verwendet, benötigst du etwa 46 GB RAM/einheitlichen Speicher. Wir empfehlen mindestens 3-Bit-Präzision für beste Leistung.

#### 🦥 Unsloth Studio-Leitfaden

Qwen3-Coder-Next kann ausgeführt und feinabgestimmt 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 auf **macOS, Windows**, Linux und:

{% columns %}
{% column %}

* Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle
* [**Selbstheilend** Tool-Aufrufe](/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](https://unsloth.ai/docs/desktop#feature-deep-dive) Abstimmung der Parameter (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="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FFeQ0UUlnjXkDdqhcWglh%2Fskinny%20studio%20chat.png?alt=media&amp;token=c2ee045f-c243-4024-a8e4-bb4dbe7bae79" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

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

Führen Sie dies 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 ca. 1–2 Min.**
{% 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 %}
**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. Anschließend 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 zum [Unsloth Chat](/docs/de/neu/studio/chat.md) Registerkarte und suche nach **Qwen3-Coder-Next** in der Suchleiste und lade das gewünschte 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&amp;token=74fb6c0f-fbd1-4506-be76-050f27de8d02" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}

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

Die 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, das Chat-Template und andere Einstellungen bearbeiten.

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

<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&amp;token=25d68698-fb13-4c46-99b2-d39fb025df08" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

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

Anweisungen zur Ausführung in llama.cpp (beachten Sie, dass wir 4-Bit verwenden werden, damit es auf die meisten Geräte passt):

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

{% 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 on` wird auch die Kontextlänge 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 über (nach der Installation von `pip install huggingface_hub`). Sie können `UD-Q4_K_XL` oder andere quantisierte Versionen. 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/Qwen3-Coder-Next-GGUF \
    --local-dir unsloth/Qwen3-Coder-Next-GGUF \
    --include "*UD-Q4_K_XL*"
```

{% endcode %}
{% endstep %}

{% step %}
Führen Sie das Modell dann 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 generiert keine `<think></think>` Blöcke in seiner Ausgabe. Daher führt das Angeben von `enable_thinking=False` nicht mehr erforderlich.
{% endhint %}
{% endstep %}
{% endstepper %}

### 🦙Llama-Server-Bereitstellung & Deployment

Um Qwen3-Coder-Next produktiv bereitzustellen, verwenden wir `llama-server` Sage 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 %}

Was Folgendes ausgibt:

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

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

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

### So führst du dies aus:
1.  Kopiere den folgenden 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 sie 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; /* Lässt Klicks zum Canvas durch */
            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>Klick</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 vorbei</h2>
                <p>Punktestand: <span id="final-score">0</span></p>
                <p>Bestwert: <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 nach links bewegten Rohre

        // --- 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"; // Goldfarbe
                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;

                // Bodenkollision
                if (this.y + this.height >= canvas.height) {
                    this.y = canvas.height - this.height;
                    gameOver();
                }
                
                // Decken-Kollision (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
                    // Minimale Höhe 50, maximale Hö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;

                    // Kollisionserkennung
                    // Logik: Prüfen, ob die X-Position des Vogels im X-Bereich des Rohrs liegt
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // Logik: Prüfen, ob die Y-Position des Vogels das obere ODER untere Rohr berührt
                        if (bird.y < p.y || bird.y + bird.height > p.y + this.gap) {
                            gameOver();
                        }
                    }

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

                    // Rohre entfernen, die aus dem Bild gelaufen sind
                    if (p.x + this.width <= 0) {
                        this.position.shift();
                        // i verringern, 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"; // Rasengrü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 leeren
            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';
        }

        // --- Eingabeverarbeitung ---

        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, das du passierst.
4.  **Highscore:** Verwendet den LocalStorage deines Browsers, um sich deinen Bestwert zu merken, selbst wenn du die Seite aktualisierst.
5.  **Reaktionsfähige 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 generierte Flappy-Bird-Beispiel hat gut funktioniert!
{% 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&amp;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 unserer Anleitung folgen. Verwende den `llama-server` wir gerade eben eingerichtet haben, und setze den Modellnamen auf die exakte ID, die es bei `GET /v1/models` (die `--alias` oben genannten Wert, `unsloth/Qwen3-Coder-Next`). Befolge die korrekten Qwen3-Coder-Next-Parameter und Nutzungsanweisungen.

{% columns %}
{% column %}
{% content-ref url="/pages/d12c953ceacbd6c3e44f3aa911056928e0488f5b" %}
[Claude Code](/docs/de/grundlagen/claude-code.md)
{% endcontent-ref %}
{% endcolumn %}

{% column %}
{% content-ref url="/pages/1813c928d883d651dff92062bc0da6e96d06e50a" %}
[OpenAI Codex](/docs/de/grundlagen/codex.md)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

Nachdem du zum Beispiel den Anweisungen für Claude Code gefolgt bist, 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&amp;token=152e9ee0-2491-4379-af18-8fca0789b19d" alt="" width="563"><figcaption></figcaption></figure>

Dann können wir zum Beispiel sagen `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&amp;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&amp;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&amp;token=996c8cb9-d199-4045-90f0-408690e02667" alt="" width="563"><figcaption></figcaption></figure></div>

Wenn du `API-Fehler: 400 {"error":{"code":400,"message":"request (16582 tokens) überschreitet die verfügbare Kontextgröße (16384 tokens), versuche sie zu erhöhen","type":"exceed_context_size_error","n_prompt_tokens":16582,"n_ctx":16384}}` das bedeutet, 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&amp;token=285a540b-f6fc-4541-b807-bf4f6dc3807b" alt=""><figcaption></figcaption></figure>

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

Du kannst jetzt unser neues [FP8-Dynamic-Quant](https://huggingface.co/unsloth/Qwen3-Coder-Next-FP8-Dynamic) des Modells für Premium- 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 findest über `nvidia-smi` - nur `cu129` und `cu130` werden derzeit unterstützt.

{% hint style="success" %}
Wenn du vLLM / SGLang verwendest, probiere unsere FP8-Dynamic-Quants aus, 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, falls du es noch 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 [Unsloths dynamische FP8-Version](https://huggingface.co/unsloth/Qwen3-Coder-Next-FP8-Dynamic) des Modells. Du kannst FP8 auch aktivieren, um die Speichernutzung des KV-Caches 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, dann CTRL+B+D – verwende `tmux attach-session -t0` um zu ihm 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 wie das Folgende sehen. Siehe [#tool-calling-with-qwen3-coder-next](#tool-calling-with-qwen3-coder-next "mention") für die tatsächliche Nutzung von Qwen3-Coder-Next mit der OpenAI-API und Tool-Calling – das funktioniert mit 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&amp;token=4f43796b-397f-4ffb-86d2-68afd14994f9" alt=""><figcaption></figcaption></figure>

### :wrench:Werkzeugaufrufe mit Qwen3-Coder-Next

In einem neuen Terminal erstellen wir einige Tools wie das Hinzufügen 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 subtract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Vor 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 es einander zu wissen, programmierte ein Freund versehentlich ein Programm, das Faultiere weiterentwickelte...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Befehle 'rm, sudo, dd, chmod' können nicht ausgeführt werden, da sie gefährlich sind"
        print(msg); return msg
    print(f"Führe Terminalbefehl `{command}` aus")
    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,
    "subtract_number": subtract_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": "subtract_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 %}

Dann verwenden wir 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"Verwendetes 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 zum Ausführen von Tool-Calling für viele verschiedene Anwendungsfälle:

#### 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&amp;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ückliches Faultier' in eine Datei und gib sie mir dann zurück."}],
}]
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 auch!

<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&amp;token=eb27f30a-c91e-4aec-8fb0-f4a35921d3db" alt=""><figcaption></figcaption></figure>

Siehe [Tool Calling Guide](/docs/de/grundlagen/tool-calling-guide-for-local-llms.md) für weitere Beispiele für Werkzeugaufrufe.

## :triangular\_ruler:Benchmarks

### GGUF-Quantisierungs-Benchmarks

Hier sind einige Quantisierungs-Benchmarks, die von unabhängigen Gutachtern 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&amp;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&amp;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 %}
Benchmarks wurden von externen Mitwirkenden auf dem Aider-Polyglot-Server ausgeführt und verglichen Unsloth-GGUF-Quantisierungen im Aider-Polyglot-Benchmark (Punktzahl vs. VRAM). Bemerkenswert ist, dass die 3-Bit **`UD-IQ3_XXS`** Quantisierung nahe an **BF16** Leistung, wodurch **3-Bit zu einem sinnvollen Minimum** für die meisten Anwendungsfälle.

**NVFP4** übertrifft die BF16-Referenz leicht, was aufgrund der begrenzten Läufe Samplingrauschen sein könnte; allerdings zeigt das Gesamtmuster für: **1-Bit → 2-Bit → 3-Bit → 6-Bit** das sich stetig verbessert, legt nahe, dass der Benchmark aussagekräftige Qualitätsunterschiede zwischen Unsloth-GGUFs erfasst. Die **nicht-Unsloth** FP8 scheint schlechter abzuschneiden als beide **`UD-IQ3_XXS`** und **`UD-Q6_K_XL`**, was Unterschiede in der Quantisierungspipeline oder erneut unzureichende Stichprobengröße widerspiegeln könnte.
{% endcolumn %}

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

Die Grafiken zeigen deutlich, dass Unsloths Q4\_K\_M-Quantisierungen besser abschneiden als standardmäßiges 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&amp;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&amp;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&amp;token=081a28bb-003c-4c92-b086-e2bef1ab91c2" alt=""><figcaption></figcaption></figure>


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/de/modelle/qwen3-coder-next.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.