🌠Qwen3-Coder-Next: Anleitung zum lokalen Betrieb

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

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

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

Update vom 4. Feb: llama.cpp behob einen Fehler bei der Korrektur der Berechnung für vektorisiertes key_gdiff. Dies behebt frühere Schleifen- und Ausgabeprobleme. Wir haben die GGUFs aktualisiert - bitte erneut herunterladen und AKTUALISIEREN llama.cpp für bessere Ausgaben.

Sie erfahren auch, wie man das Modell auf Codex & Claude Code ausführt. Für Feinabstimmungpasst Qwen3-Next-Coder für bf16 LoRA in Unsloth auf eine einzelne B200-GPU.

Qwen3-Coder-Next Unsloth Dynamische GGUFs zum Ausführen: unsloth/Qwen3-Coder-Next-GGUF

GGUF-Tutorial ausführenCodex & Claude CodeFP8 vLLM Tutorial

⚙️ Gebrauchsanleitung

Haben Sie nicht 46GB RAM oder einheitlichen Speicher? Kein Problem, Sie können unsere kleineren Quantisierungen wie 3-Bit verwenden. Am besten ist es, wenn die Modellgröße gleich der Summe Ihrer Rechnerressourcen ist ( Festplattenspeicher + RAM + VRAM ≥ Größe der Quantisierung). Wenn Ihre Quantisierung vollständig auf Ihr Gerät passt, erwarten Sie 20+ Tokens/s. Wenn sie nicht passt, funktioniert sie trotzdem durch Auslagern, ist dann aber langsamer.

Um optimale Leistung zu erzielen, empfiehlt Qwen diese Einstellungen:

• Temperatur = 1,0

• Top_P = 0,95

• Top_K = 40

• Min_P = 0.01 (llama.cpps Standard ist 0.05)

• Wiederholungsstrafe = deaktiviert oder 1,0

Unterstützt nativ bis zu 262,144 Kontext, Sie können ihn jedoch auf 32,768 Tokens für weniger Speicherverbrauch.

🖥️ Qwen3-Coder-Next ausführen

Je nach Anwendungsfall müssen Sie unterschiedliche Einstellungen verwenden. Da diese Anleitung 4-Bit nutzt, benötigen Sie etwa 46GB RAM/einheitlichen Speicher. Wir empfehlen mindestens 3-Bit-Präzision für beste Leistung.

Update vom 4. Feb: llama.cpp behob einen Fehler bei der Korrektur der Berechnung für vektorisiertes key_gdiff. Dies behebt frühere Schleifen- und Ausgabeprobleme. Wir haben die GGUFs aktualisiert - bitte erneut herunterladen und AKTUALISIEREN llama.cpp für bessere Ausgaben.

HINWEIS: Dieses Modell unterstützt nur den Nicht-Denk-Modus und erzeugt keine <think></think> Blöcke in seiner Ausgabe. Daher ist das Angeben von enable_thinking=False nicht mehr erforderlich.

Llama.cpp Tutorial (GGUF):

Anleitung zum Ausführen in llama.cpp (Hinweis: Wir verwenden 4-Bit, um die meisten Geräte passend zu machen):

1

Holen Sie sich die neueste llama.cpp auf GitHub hier. Sie können auch den unten stehenden Build-Anweisungen folgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Sie können direkt von Hugging Face ziehen. Sie können den Kontext auf 256K erhöhen, wenn Ihr RAM/VRAM das zulässt. Die Verwendung von --fit on bestimmt ebenfalls automatisch die Kontextlänge.

Sie können die empfohlenen Parameter verwenden: temperature=1.0, top_p=0.95, top_k=40

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

3

Laden Sie das Modell herunter über (nach Installation von pip install huggingface_hub). Sie können wählen UD-Q4_K_XL oder andere quantisierte Versionen.

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

4

Führen Sie dann das Modell im Konversationsmodus aus:

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

Passen Sie außerdem Kontextfenster nach Bedarf, bis zu 262,144

HINWEIS: Dieses Modell unterstützt nur den Nicht-Denk-Modus und erzeugt keine <think></think> Blöcke in seiner Ausgabe. Daher ist das Angeben von enable_thinking=False nicht mehr erforderlich.

🦙Llama-Server Bereitstellung & Deployment

Um Qwen3-Coder-Next für die Produktion bereitzustellen, verwenden wir llama-server In einem neuen Terminal, zum Beispiel via tmux. Dann das Modell deployen mit:

./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 \

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

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)

Was folgendes ausgeben wird:

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

Ich habe **HTML5 Canvas** für die Grafiken und **JavaScript** für die Physik (Schwerkraft, Kollisions­erkennung und Punktevergabe) verwendet. Keine externen Bilder oder Downloads sind erforderlich; das Spiel zeichnet Vogel und Rohrleitungen per Code.

### So führen Sie es aus:
1.  Kopieren Sie den folgenden Codeblock.
2.  Erstellen Sie eine neue Datei auf Ihrem Computer namens `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="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Simple Flappy Bird</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            height: 100vh;
            Hintergrundfarbe: #333;
            Schriftfamilie: '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;
            Hintergrundfarbe: #70c5ce; /* Himmelblau */
            Rahmen: 4px solid #000;
        }

        #ui-layer {
            position: absolute;
            oben: 0;
            links: 0;
            Breite: 100%;
            Höhe: 100%;
            pointer-events: none; /* Lassen Sie Klicks zum Canvas durch */
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            text-align: center;
        }

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

        #score-board {
            position: absolute;
            oben: 20px;
            Breite: 100%;
            text-align: center;
            Schriftgröße: 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>Klick</strong>, um zu springen</p>
                <p>Drücken Sie die Leertaste zum Starten</p>
            </div>
            <div id="game-over-screen" class="message" style="display: none;">
                <h2>Spiel Vorbei</h2>
                <p>Punkte: <span id="final-score">0</span></p>
                <p>Best: <span id="best-score">0</span></p>
                <p>Drücken Sie die <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, mit der die Rohre nach links bewegen

        // --- 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() {
                // Füge alle 120 Frames ein neues Rohr hinzu (ca. 2 Sekunden)
                if (frames % 120 === 0) {
                    // Zufällige Höhe für das obere Rohr
                    // Min Höhe 50, Max 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;

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

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

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

        // --- Hintergrund (Wolken/Gras) ---
        const background = {
            draw: function() {
                // Zeichne Gras
                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();
            }
        };

        // --- Spielsteuerungs-Funktionen ---

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

            // Hintergrund zeichnen
            background.draw();

            if (gameState === 'START') {
                bird.draw();
                // Zeichne eine Bodenlinie
                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();
                // Aktualisiere weder Frames noch Position, 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';
            
            // Aktualisiere Highscore
            if (score > highScore) {
                highScore = score;
                localStorage.setItem('flappyHighScore', highScore);
            }

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

        // --- Eingabe­verarbeitung ---

        function handleInput(e) {
            // Verhindere das standardmäßige Scrollverhalten bei Leertaste
            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.  **Kollisions­erkennung:** Das Spiel endet, wenn Sie die Rohre, den Boden oder die Decke treffen.
3.  **Punktesystem:** Sie erhalten 1 Punkt für jedes Rohr, das Sie passieren.
4.  **Highscore:** Verwendet den LocalStorage Ihres Browsers, um Ihren besten Punktestand zu speichern, auch wenn Sie die Seite neu laden.
5.  **Reaktionsschnelle Steuerung:** Funktioniert mit der **Leertaste**, **Mausklick** oder **Touch** (für Mobilgeräte).
6.  **Grafik:** Der Vogel wird per Code gezeichnet (inklusive Auge und Schnabel) und die Rohre haben Rahmen, sodass keine kaputten Bildlinks auftreten.

Wir extrahierten das HTML und führten es aus, und das erzeugte Beispiel-Flappy-Bird-Spiel funktionierte gut!

👾 OpenAI Codex & Claude Code

Um das Modell über lokale agentische Coding-Workloads auszuführen, können Sie unserer Anleitung folgen. Ändern Sie einfach den Modellnamen 'GLM-4.7-Flash' zu 'Qwen3-Coder-Next' und stellen Sie sicher, dass Sie die korrekten Qwen3-Coder-Next-Parameter und Nutzungsanweisungen befolgen. Verwenden Sie das llama-server das wir gerade eingerichtet haben.

Claude Code & OpenAI Codex

Nach Befolgung der Anweisungen für Claude Code sehen Sie zum Beispiel:

Wir können dann zum Beispiel fragen Erstelle ein Python-Spiel für Schach :

Wenn Sie sehen API-Fehler: 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}} das bedeutet, Sie müssen die Kontextlänge erhöhen oder siehe 📐Wie man langen Kontext anpasst

🎱 FP8 Qwen3-Coder-Next in vLLM

Sie können jetzt unser neues FP8 Dynamic Quant des Modells für hochwertige und schnelle Inferenz verwenden. Installieren Sie zuerst vLLM aus dem Nightly-Build. Ändern Sie --extra-index-url https://wheels.vllm.ai/nightly/cu130 zu Ihrer CUDA-Version, die Sie über nvidia-smi - nur cu129 und cu130 werden derzeit unterstützt.

# Installiere uv, falls Sie es nicht haben, für schnellere Environment-Installationen
curl -LsSf https://astral.sh/uv/install.sh | sh

# Erstelle eine neue Python-Umgebung - nicht nötig, wenn Sie Ihr ganzes System ändern wollen
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

Dann servieren Unsloths dynamische FP8-Version des Modells. Sie können FP8 auch aktivieren, um den KV-Cache-Speicherverbrauch um 50% zu reduzieren, indem Sie hinzufügen --kv-cache-dtype fp8 Wir haben es auf 4 GPUs gehostet, aber wenn Sie 1 GPU haben, verwenden Sie CUDA_VISIBLE_DEVICES='0' und setze --tensor-parallel-size 1 oder entfernen Sie dieses Argument. Verwenden Sie tmux um das Folgende in einem neuen Terminal zu starten und dann CTRL+B+D - verwenden Sie tmux attach-session -t0 um zurückzukehren.

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 so etwas wie unten sehen. Siehe Qwen3-Coder-Next wie man Qwen3-Coder-Next tatsächlich mit der OpenAI-API und Tool-Calls verwendet - das funktioniert für vLLM und llama-server.

🔧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:

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 Zeit in einer weit, weit entfernten Galaxie...",
        "Es gab zwei Freunde, die Faultiere und Code liebten...",
        "Die Welt ging zu Ende, weil jedes Faultier übermenschliche Intelligenz entwickelte...",
        "Unbekannt einem Freund, hatte der andere versehentlich ein Programm geschrieben, um Faultiere zu entwickeln...",
    ])
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,
    "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": "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": "substract_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 vom 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"],
            },
        },
    },
]

Dann verwenden wir die unten stehenden Funktionen (kopieren, einfügen und ausführen), die Funktionsaufrufe automatisch parsen und den OpenAI-Endpunkt für jedes Modell aufrufen:

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

Nun zeigen wir mehrere Methoden zur Ausführung von Tool-Calling für viele verschiedene Anwendungsfälle unten:

Generierten Python-Code ausführen

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Create a Fibonacci function in Python and find fib(20)."}],
}]
unsloth_inference(messages, temperature = 1.0, top_p = 0.95, top_k = 40, min_p = 0.00)

Beliebige Terminalbefehle ausführen

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Schreibe 'I'm a happy Sloth' in eine Datei und gib sie mir danach wieder aus."}],
}]
messages = unsloth_inference(messages, temperature = 1.0, top_p = 1.0, top_k = 40, min_p = 0.00)

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

Siehe Tool Calling Guide für weitere Beispiele zum Tool-Calling.

🛠️ Verbesserung der Generierungsgeschwindigkeit

Wenn Sie vLLM / SGLang verwenden, probieren Sie unsere FP8-Dynamic-Quantisierungen, die den Durchsatz um 25% oder mehr steigern können! Siehe 🎱 FP8 Qwen3-Coder-Next in vLLM

Wenn Sie mehr VRAM haben, können Sie versuchen, mehr MoE-Schichten auszulagern oder ganze Schichten selbst auszulagern.

Normalerweise, -ot ".ffn_.*_exps.=CPU" lagert alle MoE-Schichten auf die CPU aus! Dies ermöglicht es effektiv, alle Nicht-MoE-Schichten auf einer GPU unterzubringen und die Generationsgeschwindigkeit zu verbessern. Sie können den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie -ot ".ffn_(up|down)_exps.=CPU" Dies lagert up- und down-Projektions-MoE-Schichten aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur up-Projektions-MoE-Schichten aus.

Sie können den Regex auch anpassen, zum Beispiel -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" bedeutet, Gate-, Up- und Down-MoE-Schichten auszulagern, jedoch nur ab der 6. Schicht.

Der neueste llama.cpp-Version führt auch einen Hochdurchsatzmodus ein. Verwenden Sie llama-parallel. Lesen Sie mehr darüber hier. Sie können auch den KV-Cache auf 4 Bit quantisieren zum Beispiel, um VRAM-/RAM-Bewegungen zu reduzieren, was den Generierungsprozess ebenfalls beschleunigen kann. Die nächste Abschnitt spricht über KV-Cache-Quantisierung.

📐Wie man langen Kontext anpasst

Um längere Kontexte unterzubringen, können Sie KV-Cache-Quantisierung verwenden, um die K- und V-Caches auf niedrigere Bits zu quantisieren. Dies kann auch die Generationsgeschwindigkeit aufgrund reduzierter RAM-/VRAM-Datenbewegung erhöhen. Die erlaubten Optionen für K-Quantisierung (Standard ist f16) umfassen die folgenden.

--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1

Sie sollten die _1 Varianten für etwas erhöhte Genauigkeit verwenden, obwohl sie etwas langsamer sind. Zum Beispiel q4_1, q5_1 Probieren Sie also --cache-type-k q4_1

Sie können auch den V-Cache quantisieren, aber Sie müssen llama.cpp mit Flash Attention kompilieren Unterstützung über -DGGML_CUDA_FA_ALL_QUANTS=ON, und verwenden Sie --flash-attn um es zu aktivieren. Nachdem Sie Flash Attention installiert haben, können Sie dann --cache-type-v q4_1

Wenn Sie unsere Dynamic FP8-Quantisierungen verwenden 🎱 FP8 Qwen3-Coder-Next in vLLMkann die Verwendung der FP8 KV-Cache-Quantisierung die Kontextlängenunterstützung ungefähr verdoppeln. Fügen Sie hinzu --kv-cache-dtype fp8

📐Benchmarks

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

Benchmark	Qwen3-Coder-Next (80B)	DeepSeek-V3.2 (671B)	GLM-4.7 (358B)	MiniMax M2.1 (229B)
SWE-Bench Verifiziert (mit SWE-Agent)	70.6	70.2	74.2	74.8
SWE-Bench Mehrsprachig (mit SWE-Agent)	62.8	62.3	63.7	66.2
SWE-Bench Pro (mit SWE-Agent)	44.3	40.9	40.6	34.6
Terminal-Bench 2.0 (mit Terminus-2 json)	36.2	39.3	37.1	32.6
Aider	66.2	69.9	52.1	61.0