🌠Qwen3-Coder-Next: Wie man lokal ausführt

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

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

Update vom 19. Feb.: Tool-Aufrufe sollten nun sogar besser sein, nachdem llama.cpp das Parsing behoben hat.

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

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

Du lernst außerdem, das Modell auf Codex & Claude Code auszuführen. Für Fine-Tuningpasst Qwen3-Next-Coder auf eine einzelne B200-GPU für bf16 LoRA in Unsloth.

Qwen3-Coder-Next Unsloth Dynamic GGUFs auszuführen: unsloth/Qwen3-Coder-Next-GGUF

GGUF-Tutorial ausführenCodex & Claude CodeFP8 vLLM-Tutorial

⚙️ Verwendungsleitfaden

Du hast keine 46 GB RAM oder Unified Memory? Kein Problem, du kannst unsere kleineren Quants wie 3-Bit ausführen. Am besten ist es, wenn die Modellgröße = der Summe deiner Rechenressourcen ist ( Festplattenspeicher + RAM + VRAM ≥ Größe des Quants). Wenn dein Quant vollständig auf dein Gerät passt, kannst du mit 20+ Tokens/s rechnen. Wenn nicht, funktioniert es trotzdem per Auslagern, 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 Standardwert ist 0.05)

• Wiederholungsstrafe = deaktiviert oder 1.0

Unterstützt nativ bis zu 262,144 Kontext, aber du kannst ihn auf 32,768 Tokens setzen, um weniger Speicher zu verbrauchen.

🖥️ Qwen3-Coder-Next ausführen

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

Update vom 4. Feb.: llama.cpp einen Fehler behoben, der die Berechnung für vektorisiertes key_gdiff korrigiert. Damit werden frühere Schleifen- und Ausgabeprobleme behoben. Wir haben die GGUFs aktualisiert – bitte erneut herunterladen und AKTUALISIERUNG llama.cpp für bessere Ausgaben.

HINWEIS: Dieses Modell unterstützt nur den Nicht-Denkmodus 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):

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

1

Beschaffe die neueste llama.cpp auf GitHub hier. Du kannst unten auch den Build-Anweisungen folgen. Ändere -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder nur CPU-Inferenz möchtest. Für Apple Mac / Metal-Geräte, setze -DGGML_CUDA=OFF und fahre dann wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert.

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

Du kannst direkt von Hugging Face ziehen. Du kannst den Kontext auf 256K erhöhen, wenn dein RAM/VRAM dafür ausreicht. Die Verwendung von --fit on wird die Kontextlänge ebenfalls automatisch bestimmen.

Du kannst 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

Lade das Modell über (nach Installation von pip install huggingface_hub). Du kannst UD-Q4_K_XL oder andere quantisierte Versionen. Wenn Downloads hängen bleiben, siehe Hugging Face Hub, XET-Debugging

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ühre das Modell im Gesprächsmodus 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 wie erforderlich, bis zu 262,144

HINWEIS: Dieses Modell unterstützt nur den Nicht-Denkmodus 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 den produktiven Einsatz bereitzustellen, verwenden wir llama-server In einem neuen Terminal, z. B. über tmux. Dann das Modell bereitstellen 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 du pip install openaikö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": "Create a Flappy Bird game in HTML"},],
)
print(completion.choices[0].message.content)

Was Folgendes ausgibt:

Hier ist ein vollständiges, funktionsfähiges Flappy-Bird-Spiel, das in einer einzigen Datei enthalten ist.

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

### So führst du es aus:
1.  Kopiere den untenstehenden Codeblock.
2.  Erstelle auf deinem Computer eine neue Datei mit dem Namen `game.html`.
3.  Füge den Code in diese Datei ein und speichere sie.
4.  Doppelklicke auf `game.html`, um sie in deinem 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>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; /* Himmelsblau */
            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>Bist du bereit zu fliegen?</h2>
                <p>Drücke <strong>Leertaste</strong> oder <strong>Klick</strong>, um zu springen</p>
                <p>Drücke Leertaste, um zu starten</p>
            </div>
            <div id="game-over-screen" class="message" style="display: none;">
                <h2>Spiel vorbei</h2>
                <p>Punktzahl: <span id="final-score">0</span></p>
                <p>Bestwert: <span id="best-score">0</span></p>
                <p>Drücke <strong>Leertaste</strong>, um neu zu starten</p>
            </div>
        </div>
    </div>

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

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

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

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

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

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

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

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

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

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

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

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

                    // Kollisionserkennung
                    // Logik: Prüfen, ob sich die X-Position des Vogels im X-Bereich des Rohrs befindet
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // Logik: Prüfen, ob die Y-Position des Vogels das obere ODER untere Rohr 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 außerhalb des Bildschirms liegen
                    if (p.x + this.width <= 0) {
                        this.position.shift();
                        // i dekrementieren, da sich die Array-Länge geändert hat
                        i--; 
                    }
                }
            },
            
            reset: function() {
                this.position = [];
            }
        };

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

        // --- Spielfunktionen ---

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

            // Hintergrund zeichnen
            background.draw();

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

            requestAnimationFrame(loop);
        }

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

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

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

        // --- Eingabebehandlung ---

        function handleInput(e) {
            // Standardmäßiges Scrollen bei Leertaste verhindern
            if (e.type === 'keydown' && e.code === 'Space') {
                e.preventDefault();
            }

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

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

        // Initialisieren
        loop();

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

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

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 Coding-Workloads auszuführen, können Sie unseren Leitfaden befolgen. Ändere einfach den Modellnamen 'GLM-4.7-Flash' zu 'Qwen3-Coder-Next' und stelle sicher, dass du die korrekten Parameter und Nutzungsanweisungen für Qwen3-Coder-Next befolgst. Verwende die llama-server die wir gerade eben eingerichtet haben.

Claude Code

OpenAI Codex

Nachdem Sie zum Beispiel die Anweisungen für Claude Code befolgt haben, sehen Sie:

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

Wenn du 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}} siehst, bedeutet das, dass du die Kontextlänge erhöhen musst oder siehe Qwen3-Coder-Next

🎱 FP8 Qwen3-Coder-Next in vLLM

Du kannst jetzt unser neues FP8 Dynamic Quant des Modells für schnelle Premium-Inferenz verwenden. Installiere zuerst vLLM aus dem Nightly-Build. Ändere --extra-index-url https://wheels.vllm.ai/nightly/cu130 auf deine CUDA-Version, die du über nvidia-smi findest - nur cu129 und cu130 werden derzeit unterstützt.

Wenn du vLLM / SGLang verwendest, probiere unsere FP8-Dynamic-Quants aus, die den Durchsatz um 25% oder mehr steigern können! Siehe 🎱 FP8 Qwen3-Coder-Next in vLLM

# Installiere uv, falls du es nicht hast, für schnellere Umgebungsinstallationen
curl -LsSf https://astral.sh/uv/install.sh | sh

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

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

Dann bereitstellen Unsloths dynamische FP8-Version des Modells. Du kannst FP8 auch aktivieren, um die KV-Cache-Speichernutzung um 50% zu reduzieren, indem du --kv-cache-dtype fp8 Wir haben es auf 4 GPUs bereitgestellt, aber wenn du 1 GPU hast, verwende CUDA_VISIBLE_DEVICES='0' und setze --tensor-parallel-size 1 oder entferne dieses Argument. Verwende tmux um das Folgende in einem neuen Terminal zu starten und dann CTRL+B+D - verwende 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

Du solltest etwas wie unten sehen. Siehe Qwen3-Coder-Next für die tatsächliche Verwendung von Qwen3-Coder-Next über die OpenAI-API und Tool-Calling – 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, langer Zeit in einer weit, weit entfernten Galaxie...",
        "Es gab 2 Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil sich jedes Faultier zu übermenschlicher Intelligenz entwickelte...",
        "Ohne es zu wissen, hatte einer der Freunde 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"Ausführen des Terminalbefehls `{command}`")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Befehl fehlgeschlagen: {e.stderr}"
def python(code: str) -> str:
    data = {}
    exec(code, data)
    del data["__builtins__"]
    return str(data)
MAP_FN = {
    "add_number": add_number,
    "multiply_number": multiply_number,
    "substract_number": substract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Addiert 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 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"],
            },
        },
    },
]

Wir verwenden dann die folgenden Funktionen (kopieren, einfügen und ausführen), die die Funktionsaufrufe automatisch analysieren und für jedes Modell den OpenAI-Endpunkt 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

Jetzt zeigen wir unten mehrere Methoden, Tool-Calling für viele verschiedene Anwendungsfälle auszuführen:

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 Terminalfunktionen ausführen

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Write 'I'm a happy Sloth' to a file, then print it back to me."}],
}]
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 für Tool-Calling.

📐Benchmarks

GGUF-Quantisierungs-Benchmarks

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

Aider Polyglot Benchmarks

Benjamine Marie Benchmarks (Quelle)

Die Benchmarks wurden von unabhängigen Mitwirkenden auf dem Aider-Polyglot-Server durchgeführt und verglichen Unsloth-GGUF-Quantisierungen auf dem Aider-Polyglot-Benchmark (Score vs. VRAM). Bemerkenswert ist, dass die 3-Bit UD-IQ3_XXS Quant kommt nahe an BF16 Leistung heran, was 3-Bit zu einem sinnvollen Minimum für die meisten Anwendungsfälle macht.

NVFP4 übertrifft die BF16-Referenz leicht, was möglicherweise auf Sampling-Rauschen aufgrund begrenzter Durchläufe zurückzuführen ist; insgesamt deutet das Muster für: 1-Bit → 2-Bit → 3-Bit → 6-Bit das stetig besser wird, darauf hin, dass der Benchmark aussagekräftige Qualitätsunterschiede über die Unsloth GGUFs hinweg erfasst. Das nicht-Unsloth FP8 scheint schlechter abzuschneiden als beide UD-IQ3_XXS und UD-Q6_K_XL, was Unterschiede in der Quantisierungspipeline oder erneut unzureichendes Sampling widerspiegeln könnte.

Benjamin Marie (Drittanbieter) hat Benchmarks durchgeführt Qwen3-Coder-Next unter Verwendung von Unsloth und Qwen-GGUFs auf einem 750-Prompt-Mix-Suite (LiveCodeBench v6, MMLU Pro, GPQA, Math500), wobei sowohl Gesamtgenauigkeit und relative Fehlerzunahme (wie viel häufiger das quantisierte Modell im Vergleich zum Original Fehler macht).

Die Diagramme zeigen deutlich, dass Unsloths Q4_K_M-Quantisierungen besser abschneiden als das Standard-Q4_K_M. Q3_K_M schneidet erwartungsgemäß beim 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.

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.

Benchmark	Qwen3-Coder-Next (80B)	DeepSeek-V3.2 (671B)	GLM-4.7 (358B)	MiniMax M2.1 (229B)
SWE-Bench Verified (mit SWE-Agent)	70.6	70.2	74.2	74.8
SWE-Bench Multilingual (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