🌠Qwen3-Coder-Next: Anleitung zum lokalen Ausführen

Anleitung 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/vereinheitlichtem Speicher (85GB für 8-Bit), ist nicht-denkend für ultraschnelle Code-Antworten. Das Modell glänzt bei Langzeitschlussfolgerungen, komplexem Tool-Einsatz und der Wiederherstellung nach Ausführungsfehlern.

Update 19. Feb: Tool-Aufrufe sollten jetzt nach llama.cpp-Parsingskorrekturen noch besser funktionieren.

NEU! Siehe Quantisierungs-Benchmarks für unsere Dynamic GGUFs!

4. Feb: llama.cpp hat einen Fehler behoben, der die Berechnung für vektorisierten key_gdiff korrigierte. Das behebt frühere Schleifen- und Ausgabeprobleme. Wir haben die GGUFs aktualisiert - bitte neu 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 Dynamic GGUFs zum Ausführen: unsloth/Qwen3-Coder-Next-GGUF

GGUF-Tutorial ausführenCodex & Claude CodeFP8 vLLM Tutorial

⚙️ Gebrauchsanleitung

Haben Sie nicht 46GB RAM oder vereinheitlichten Speicher? Kein Problem, Sie können unsere kleineren Quants wie 3-Bit ausführen. Am besten ist, wenn die Modellgröße gleich der Summe Ihrer Rechenressourcen 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, wird 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 bis zu 262,144 Kontext nativ, aber Sie können ihn auf 32,768 Tokens einstellen, um weniger Speicher zu verwenden.

🖥️ Qwen3-Coder-Next ausführen

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

Update 4. Feb: llama.cpp hat einen Fehler behoben, der die Berechnung für vektorisierten key_gdiff korrigierte. Das behebt frühere Schleifen- und Ausgabeprobleme. Wir haben die GGUFs aktualisiert - bitte neu herunterladen und AKTUALISIEREN llama.cpp für bessere Ausgaben.

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

Llama.cpp Tutorial (GGUF):

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

1

Holen Sie sich das neueste llama.cpp auf GitHub hier. Sie können auch den untenstehenden Build-Anweisungen folgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn Sie keine GPU haben oder nur CPU-Inferenz möchten.

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 dies zulässt. Die Verwendung von --fit on bestimmt auch 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 via (nach der Installation von pip install huggingface_hub). Sie können UD-Q4_K_XL oder andere quantisierte Versionen wählen. Wenn Downloads hängen bleiben, siehe Hugging Face Hub, XET-Debugging

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

Dann führen Sie 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 das Kontextfenster bei Bedarf an, bis zu 262,144

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

🦙Llama-server Bereitstellung & Deployment

Um Qwen3-Coder-Next für die Produktion bereitzustellen, verwenden wir llama-server Öffnen Sie in einem neuen Terminal z. B. via tmux. Dann bereitstellen Sie das Modell 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 openaiausgeführt haben, können wir das Modell starten:

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": "Create a Flappy Bird game in HTML"},],
)
print(completion.choices[0].message.content)

Was Folgendes ausgeben wird:

Hier ist ein komplettes, 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 den Vogel und die Rohre per Code.

### So führen Sie es aus:
1.  Kopieren Sie den folgenden Codeblock.
2.  Erstellen Sie auf Ihrem Computer eine neue Datei 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;
            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; /* Sky blue */
            border: 4px solid #000;
        }

        #ui-layer {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none; /* Let clicks pass through to canvas */
            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 Clone</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>Ready to Fly?</h2>
                <p>Press <strong>Space</strong> or <strong>Click</strong> to Jump</p>
                <p>Press Space to Start</p>
            </div>
            <div id="game-over-screen" class="message" style="display: none;">
                <h2>Game Over</h2>
                <p>Score: <span id="final-score">0</span></p>
                <p>Best: <span id="best-score">0</span></p>
                <p>Press <strong>Space</strong> to Restart</p>
            </div>
        </div>
    </div>

    <script>
        // --- Configuration ---
        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');

        // Game Variables
        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; // Speed of pipes moving left

        // --- The Bird Object ---
        const bird = {
            x: 50,
            y: 150,
            width: 30,
            height: 30,
            velocity: 0,
            jumpStrength: 4.5,
            radius: 15,
            draw: function() {
                ctx.fillStyle = "#FFD700"; // Gold color
                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();

                // Eye
                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();
                
                // Beak
                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;

                // Floor Collision
                if (this.y + this.height >= canvas.height) {
                    this.y = canvas.height - this.height;
                    gameOver();
                }
                
                // Ceiling Collision (Optional: prevents flying over pipes)
                if (this.y < 0) {
                    this.y = 0;
                    this.velocity = 0;
                }
            },
            jump: function() {
                this.velocity = -this.jumpStrength;
            },
            reset: function() {
                this.y = 150;
                this.velocity = 0;
            }
        };

        // --- The Pipes Array ---
        const pipes = {
            position: [],
            width: 50,
            gap: 120, // Space between top and bottom pipe
            dx: 2, // Movement speed

            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"; // Forest Green

                    // Top Pipe
                    ctx.fillRect(p.x, 0, this.width, topY);
                    ctx.strokeRect(p.x, 0, this.width, topY);

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

            update: function() {
                // Add new pipe every 120 frames (approx 2 seconds)
                if (frames % 120 === 0) {
                    // Random height for top pipe
                    // Min height 50, Max height 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;

                    // Collision Detection
                    // Logic: Check if bird X is within pipe X range
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // Logic: Check if bird Y is hitting Top Pipe OR Bottom Pipe
                        if (bird.y < p.y || bird.y + bird.height > p.y + this.gap) {
                            gameOver();
                        }
                    }

                    // Score Update (when bird passes pipe)
                    if (p.x + this.width < bird.x && !p.passed) {
                        score++;
                        scoreElement.innerText = score;
                        p.passed = true;
                    }

                    // Remove pipes that have gone off screen
                    if (p.x + this.width <= 0) {
                        this.position.shift();
                        // Decrement i because array length changed
                        i--; 
                    }
                }
            },
            
            reset: function() {
                this.position = [];
            }
        };

        // --- Background (Clouds/Grass) ---
        const background = {
            draw: function() {
                // Draw Grass
                ctx.fillStyle = "#7cfc00"; // Lawn Green
                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();
            }
        };

        // --- Game Control Functions ---

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

            // Draw Background
            background.draw();

            if (gameState === 'START') {
                bird.draw();
                // Draw a ground line
                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();
                // Don't update frames or position, just freeze
            }

            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';
            
            // Update High Score
            if (score > highScore) {
                highScore = score;
                localStorage.setItem('flappyHighScore', highScore);
            }

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

        // --- Input Handling ---

        function handleInput(e) {
            // Prevent default scrolling behavior for Space
            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);

        // Initialize
        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.  **Punktsystem:** 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 haben das HTML extrahiert und ausgeführt, und das erzeugte Beispiel-Flappy-Bird-Spiel funktionierte gut!

👾 OpenAI Codex & Claude Code

Um das Modell für lokale agentische Codier-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

Nachdem Sie z. B. die Anweisungen für Claude Code befolgt haben, sehen Sie:

Wir können dann beispielsweise fragen Create a Python game for Chess :

Wenn Sie sehen API Error: 400 {"error":{"code":400,"message":"request (16582 tokens) exceeds the available context size (16384 tokens), try increasing it","type":"exceed_context_size_error","n_prompt_tokens":16582,"n_ctx":16384}} bedeutet das, dass Sie die Kontextlänge erhöhen müssen oder siehe Qwen3-Coder-Next

🎱 FP8 Qwen3-Coder-Next in vLLM

Sie können jetzt unsere neue FP8 Dynamic-Quantisierung 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 auf Ihre CUDA-Version, die Sie mit nvidia-smi finden - nur und cu129 cu130

werden derzeit unterstützt. 🎱 FP8 Qwen3-Coder-Next in vLLM

Wenn Sie vLLM / SGLang verwenden, versuchen Sie unsere FP8-Dynamic-Quants, die den Durchsatz um 25% oder mehr steigern können! Siehe
# Installieren Sie uv, falls Sie es nicht haben, für schnellere Umfeld-Installationen

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 Unsloths dynamische FP8-Version des Modells. Sie können FP8 auch aktivieren, um die KV-Cache-Speichernutzung um 50 % zu reduzieren, indem Sie --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 und dann CTRL+B+D - verwenden Sie tmux attach-session -t0 um wieder dorthin 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 etwas Ähnliches wie unten sehen. Siehe Qwen3-Coder-Next wie man Qwen3-Coder-Next tatsächlich mit der OpenAI-API und Tool-Calls verwendet - dies funktioniert für vLLM und llama-server.

🔧Tool-Aufrufe 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 entfernten Galaxie...",
        "Es gab zwei Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil jedes Faultier sich zu übermenschlicher Intelligenz entwickelte...",
        "Ohne dass es einer der Freunde wusste, programmierte der andere versehentlich ein Programm, 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 Terminal-Befehl `{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 über das 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"],
            },
        },
    },
]

Anschließend verwenden wir die folgenden 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 zum Ausführen von Tool-Calls für viele verschiedene Anwendungsfälle unten:

Ausführung generierten Python-Codes

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)

Ausführen beliebiger Terminal-Funktionen

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Schreibe 'I'm a happy Sloth' in eine Datei und gib sie mir dann 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 war sie!

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

📐Benchmarks

GGUF-Quantisierungs-Benchmarks

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

Aider Polyglot Benchmarks

Benjamine Marie Benchmarks (Quelle)

Benchmarks wurden von Drittbeiträgern auf dem Aider Polyglot-Server durchgeführt und verglichen Unsloth-GGUF-Quantisierungen im Aider Polyglot-Benchmark (Punktzahl vs. VRAM). Bemerkenswert ist, dass die 3-Bit- UD-IQ3_XXS Quant kommt nahe an BF16 Leistung, wodurch 3-Bit ein vernünftiges Minimum für die meisten Anwendungsfälle ist.

NVFP4 übertrifft die BF16-Referenz leicht, was Probenrauschen aufgrund begrenzter Läufe sein kann; das allgemeine Muster für: 1-Bit → 2-Bit → 3-Bit → 6-Bit stetige Verbesserung legt nahe, dass der Benchmark bedeutende 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, wiederum, unzureichende Stichprobengröße widerspiegeln könnte.

Benjamin Marie (Drittanbieter) hat bewertet Qwen3-Coder-Next unter Verwendung von Unsloth- und Qwen-GGUFs auf einer 750-Prompt-Mischsuite (LiveCodeBench v6, MMLU Pro, GPQA, Math500) und berichtete sowohl Gesamtgenauigkeit und relative Fehlerzunahme (wie viel häufiger das quantisierte Modell Fehler macht im Vergleich zum Original).

Die Grafiken zeigen deutlich, dass Unsloths Q4_K_M-Quants besser abschneiden als das Standard-Q4_K_M. Q3_K_M schneidet erwartungsgemäß schlechter auf Live Code Bench v6 ab, aber überraschenderweise deutlich besser auf HumanEval als das Standard-Q4_K_M. Es scheint am effizientesten zu laufen; die Verwendung von mindestens Q4_K_M wird empfohlen.

Qwen3-Coder-Next 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