> 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: 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 Programmieren und die lokale Nutzung. Es ist vergleichbar mit der Leistung von Modellen mit 10–20× mehr aktiven Parametern.

Es läuft auf **46 GB RAM**/VRAM/Unified Memory (85 GB für 8-Bit), ist ohne 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" %}
**19. Feb.-Update**: Tool-Aufrufe sollten jetzt nach den Parsing-Fixes in llama.cpp sogar noch besser sein.

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

**4. Feb.:** `llama.cpp` einen Fehler behoben, der die Berechnung für `vektorisiertes key_gdiff.` Dadurch werden frühere Schleifen- und Ausgabeprobleme behoben. Wir haben die GGUFs aktualisiert – bitte **erneut herunterladen** und **AKTUALISIERUNG** `llama.cpp` für bessere Ausgaben.
{% endhint %}

Sie werden außerdem lernen, das Modell auf Codex & Claude Code auszuführen. Für **Feinabstimmung**, passt Qwen3-Next-Coder in Unsloth auf eine einzelne B200-GPU für bf16-LoRA.

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

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

### ⚙️ Nutzungsleitfaden

Sie haben keine 46 GB RAM oder Unified Memory? Keine Sorge, Sie können unsere kleineren Quants wie 3-Bit verwenden. Am besten ist es, wenn die Modellgröße = der Summe Ihrer Rechenressourcen ( **`Speicherplatz + RAM + VRAM ≥ Größe des Quants).`** Wenn Ihr Quant vollständig auf Ihr Gerät passt, erwarten Sie 20+ Tokens/s. Wenn nicht, funktioniert es trotzdem per Auslagerung, ist aber langsamer.

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` (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 ihn auf `32,768` Tokens reduzieren, um weniger Speicher zu verwenden.

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

Je nach Anwendungsfall müssen Sie unterschiedliche Einstellungen verwenden. Da dieser Leitfaden 4-Bit verwendet, benötigen Sie etwa 46 GB RAM/Unified Memory. 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-Weboberfläche 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
* [**Selbstheilendes** Tool-Calling](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche**
* [**Codeausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash)
* [Automatische Inferenz](/docs/de/neu/studio.md#model-arena) Parametertuning (Temp, Top-P usw.)
* Schnelle CPU- + GPU-Inferenz über llama.cpp
* [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70 % weniger VRAM
  {% endcolumn %}

{% column %}

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

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

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 Min.**
{% 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 müssen Sie ein Passwort erstellen, um Ihr Konto zu sichern, und sich später erneut anmelden. Anschließend sehen Sie einen kurzen Einrichtungsassistenten, um ein Modell, einen Datensatz und grundlegende Einstellungen auszuwählen. Sie können ihn jederzeit überspringen und direkt zum Chat wechseln.

Dann gehe zum [Studio Chat](/docs/de/neu/studio/chat.md) Registerkarte und suchen Sie nach **Qwen3-Coder-Next** in der Suchleiste und laden Sie Ihr gewünschtes Modell und Quant herunter.

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

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

Die Inferenzparameter sollten bei Verwendung von 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.

Weitere Informationen findest du in unserem [Unsloth-Studio-Inferenzleitfaden](/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 %}

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

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

{% stepper %}
{% step %}
Holen Sie sich die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Sie können auch die Build-Anweisungen unten 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 %}
Sie können direkt von Hugging Face abrufen. Sie können den Kontext auf 256K erhöhen, wenn Ihr RAM/VRAM dafür ausreicht. Bei Verwendung von `--fit auf` wird außerdem die Kontextlänge automatisch bestimmt.

Sie können 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 %}
Laden Sie das Modell über Folgendes herunter (nach der Installation von `pip install huggingface_hub`). Sie können wählen `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 %}
Dann führen Sie 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 %}

Außerdem anpassen **Kontextfenster** nach Bedarf an, bis zu `262,144`

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

### 🦙 Llama-Server-Bereitstellung & Deployment

Um Qwen3-Coder-Next für den Produktionseinsatz bereitzustellen, verwenden wir `llama-server` Öffnen Sie in einem neuen Terminal, z. B. über tmux. Stellen Sie das Modell dann mit folgendem Befehl bereit:

{% 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 führen Sie in einem neuen Terminal nach `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 ergibt folgende Ausgabe:

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

````markdown
Hier ist ein vollständiges, funktionsfähiges 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 Vogel und Rohre per Code.

### So führen Sie dies aus:
1.  Kopieren Sie den folgenden Codeblock.
2.  Erstellen Sie auf Ihrem Computer eine neue Datei mit dem Namen `game.html`.
3.  Fügen Sie den Code in diese Datei ein und speichern Sie sie.
4.  Doppelklicken Sie auf `game.html`, um es in Ihrem 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ücken Sie <strong>Leertaste</strong> oder <strong>Klicken</strong>, um zu springen</p>
                <p>Drücken Sie 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ücken Sie <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;

                // Boden-Kollision
                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
                    // 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;

                    // 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 das untere Rohr trifft
                        if (bird.y < p.y || bird.y + bird.height > p.y + this.gap) {
                            gameOver();
                        }
                    }

                    // Punktestand aktualisieren (wenn der Vogel am Rohr vorbeifliegt)
                    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 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"; // 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 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';
            
            // Höchstpunktzahl 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 dieser Version:
1.  **Physik:** Realistische Schwerkraft und Sprungmechanik.
2.  **Kollisionserkennung:** Das Spiel endet, wenn Sie die Rohre, den Boden oder die Decke berühren.
3.  **Punktesystem:** Sie erhalten 1 Punkt für jedes Rohr, an dem Sie vorbeikommen.
4.  **Höchstpunktzahl:** Verwendet den LocalStorage Ihres Browsers, um sich Ihre beste Punktzahl zu merken, selbst wenn Sie die Seite aktualisieren.
5.  **Reaktionsfähige Steuerung:** Funktioniert mit der **Leertaste**, dem **Mausklick** oder **Touch** (für Mobilgerä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 Beispiel-Flappy-Bird-Spiel hat gut funktioniert!
{% endcolumn %}

{% column width="33.33333333333334%" %}

<figure><img src="/files/41a37ce84ba4bece3f6496e7b191c14222772b1b" 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, können Sie unserer Anleitung folgen. Verwenden Sie den `llama-server` wir gerade eben eingerichtet haben, und setzen Sie den Modellnamen auf die genaue ID, die es meldet unter `GET /v1/models` (der `--alias` Wert oben, `unsloth/Qwen3-Coder-Next`). Befolgen Sie die korrekten Parameter und Anweisungen zur Verwendung von Qwen3-Coder-Next.

{% 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 Sie zum Beispiel die Anweisungen für Claude Code befolgt haben, werden Sie sehen:

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

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

<div><figure><img src="/files/eba6ddd22858ebe5043a593056568c701079f646" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="/files/62cff537cbd1853e00a15adeb5a97254daceea81" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="/files/8c0280989d7d2acb23f4f9641aba1c285c014e85" alt="" width="563"><figcaption></figcaption></figure></div>

Wenn Sie `API-Fehler: 400 {"error":{"code":400,"message":"Anfrage (16582 Tokens) überschreitet die verfügbare Kontextgröße (16384 Tokens), versuchen Sie, sie zu erhöhen","type":"exceed_context_size_error","n_prompt_tokens":16582,"n_ctx":16384}}` dass das bedeutet, dass Sie die Kontextlänge erhöhen müssen oder siehe [#how-to-fit-long-context-256k-to-1m](#how-to-fit-long-context-256k-to-1m "mention")

<figure><img src="/files/4497b468977e8f49de4e49e9ae613f40e7f49e42" alt=""><figcaption></figcaption></figure>

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

Sie können jetzt unser neues [FP8-Dynamic-Quantisierung](https://huggingface.co/unsloth/Qwen3-Coder-Next-FP8-Dynamic) des Modells für Premium- und schnelle Inferenz. Installieren Sie zuerst vLLM aus dem Nightly-Build. Ändern Sie `--extra-index-url https://wheels.vllm.ai/nightly/cu130` auf Ihre CUDA-Version, ermittelt mit `nvidia-smi` - nur `cu129` und `cu130` werden derzeit unterstützt.

{% hint style="success" %}
Wenn Sie vLLM / SGLang verwenden, versuchen Sie 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
# Installieren Sie uv, falls Sie es noch nicht haben, für schnellere Installationen der Umgebung
curl -LsSf https://astral.sh/uv/install.sh | sh

# Erstellen Sie eine neue Python-Umgebung – nicht nötig, wenn Sie Ihr gesamtes System ändern möchten
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. Sie können außerdem FP8 aktivieren, um die Speichernutzung des KV-Caches um 50 % zu reduzieren, indem Sie hinzufügen `--kv-cache-dtype fp8` Wir haben es auf 4 GPUs bereitgestellt, aber wenn Sie 1 GPU haben, verwenden Sie `CUDA_VISIBLE_DEVICES='0'` und setzen Sie `--tensor-parallel-size 1` oder entfernen Sie dieses Argument. Verwenden Sie `tmux` um das Folgende in einem neuen Terminal zu starten, dann CTRL+B+D – verwenden Sie `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
```

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

<figure><img src="/files/77a46a8be3b8c5d02d6c93b0ab01fde4c23c4cb1" 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 subtract_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 Galaxis...",
        "Es gab 2 Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil sich jedes Faultier zu übermenschlicher Intelligenz entwickelt hatte...",
        "Ohne dass es ein Freund wusste, hatte der andere versehentlich ein Programm geschrieben, 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"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": "Multipliziert 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": "Subtrahiert 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ührt Operationen im Terminal aus.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "Der Befehl, den Sie ausführen möchten, z. B. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Ruft 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 %}

Anschließend verwenden wir die untenstehenden Funktionen (kopieren, einfügen und ausführen), die die Funktionsaufrufe automatisch parsen und den OpenAI-Endpunkt für jedes Modell 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, Tool-Calling für viele verschiedene Anwendungsfälle auszuführen:

#### Generierten Python-Code ausführen

{% code overflow="wrap" %}

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

{% endcode %}

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

#### Beliebige Terminalfunktionen ausführen

{% code overflow="wrap" %}

```python
messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Schreiben Sie 'Ich bin ein glückliches Faultier' in eine Datei und geben Sie es 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 sie wurde es!

<figure><img src="/files/1a102040c551784779fb2d749c3616e8a1ed5049" alt=""><figcaption></figcaption></figure>

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

## :triangular\_ruler:Benchmarks

### GGUF-Quantisierungs-Benchmarks

Hier sind einige Quantisierungs-Benchmarks, die von externen Gutachtern durchgeführt wurden.

<div><figure><img src="/files/de0c2f5e2ebdc5b1991df9a77cfd0eff82d7321f" alt="" width="563"><figcaption><p>Aider-Polyglot-Benchmarks</p></figcaption></figure> <figure><img src="/files/5a161268a218457077febd58e55816b4d03592da" 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 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 kommt nahe an **BF16** die Leistung heran, wodurch **3-Bit zu einem sinnvollen Minimum** für die meisten Anwendungsfälle macht.

**NVFP4** übertrifft die BF16-Referenz leicht, was aufgrund der begrenzten Anzahl von Durchläufen Rauschen durch Stichproben sein könnte; das Gesamtmuster für: **1-bit → 2-bit → 3-bit → 6-bit** kontinuierlich verbessernd zeigt, dass der Benchmark bedeutungsvolle Qualitätsunterschiede zwischen Unsloth-GGUFs erfasst. Das **Nicht-Unsloth** FP8 scheint schlechter abzuschneiden als sowohl **`UD-IQ3_XXS`** und **`UD-Q6_K_XL`**, was Unterschiede in der Quantisierungspipeline oder wiederum eine unzureichende Stichprobengröße widerspiegeln könnte.
{% 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 **gemischten Suite mit 750 Prompts** (LiveCodeBench v6, MMLU Pro, GPQA, Math500), wobei sowohl **die Gesamtgenauigkeit** und **die relative Fehlerzunahme** (wie viel häufiger das quantisierte Modell im Vergleich zum Original Fehler macht).

Die Grafiken zeigen klar, dass Unsloths Q4\_K\_M-Quants besser abschneiden als das Standard-Q4\_K\_M. Q3\_K\_M schneidet erwartungsgemäß im Live Code Bench v6 schlechter ab, aber überraschenderweise bei HumanEval deutlich besser als das Standard-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 mit Modellen vergleichbar, die 10–20× mehr aktive Parameter haben.

<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="/files/f0c5766f219b9637b14aa8104994acce02e24b98" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/abcf0396e7754da7af1421eb55771b2323ff74cd" 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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

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

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

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.