🌠Qwen3-Coder-Next: Anleitung zum lokalen Betrieb

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/einheitlichem Speicher (85GB für 8-Bit), ist nicht-denkend für ultraschnelle Code-Antworten. Das Modell ist hervorragend bei Langzeit-Reasoning, komplexer Werkzeugnutzung und der Wiederherstellung nach Ausführungsfehlern.

Update vom 19. Feb: Tool-Aufrufe sollten jetzt nach den llama.cpp-Parser-Fixes noch besser sein.

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

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

Sie lernen außerdem, das Modell auf Codex & Claude Code auszuführen. Für Feinabstimmung, Qwen3-Next-Coder passt 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 keinen 46GB RAM oder einheitlichen Speicher? Kein Problem — Sie können unsere kleineren Quants wie 3-Bit verwenden. Am besten ist, wenn die Modellgröße gleich der Summe Ihrer Rechenressourcen ist ( Festplattenspeicher + RAM + VRAM ≥ Größe des Quants). Wenn Ihr Quant vollständig auf Ihr Gerät passt, rechnen Sie mit 20+ Tokens/s. Wenn es nicht passt, funktioniert es weiterhin durch Auslagerung, wird aber langsamer.

Um optimale Leistung zu erreichen, empfiehlt Qwen diese Einstellungen:

• Temperatur = 1.0

• Top_P = 0.95

• Top_K = 40

• Min_P = 0.01 (llama.cpp's 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 für geringeren Speicherverbrauch setzen.

🖥️ Qwen3-Coder-Next ausführen

Je nach Anwendungsfall benötigen Sie unterschiedliche Einstellungen. Da dieses Handbuch 4-Bit verwendet, 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, der die Berechnung für vektorisierten key_gdiff korrigierte. Das 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 generiert keine <think></think> Blöcke in seiner Ausgabe. Daher ist die Angabe von enable_thinking=False 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 Build-Anweisungen unten folgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder einfach 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

Sie können direkt von Hugging Face ziehen. Sie können den Kontext auf 256K erhöhen, wenn Ihr RAM/VRAM es 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 über (nach Installation von pip install huggingface_hub). Sie können UD-Q4_K_XL oder andere quantisierte Versionen. Falls 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 das Modell im Konversationsmodus ausführen:

./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 wie benötigt an, bis zu 262,144

HINWEIS: Dieses Modell unterstützt nur den Nicht-Denk-Modus und generiert keine <think></think> Blöcke in seiner Ausgabe. Daher ist die Angabe 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, z. B. via tmux. Dann stellen Sie das Modell bereit 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 ausgibt:

Hier ist ein vollständiges, funktionierendes 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, Kollisionsabfrage und Punktewertung) verwendet. Keine externen Bilder oder Downloads sind erforderlich; das Spiel zeichnet den Vogel und die Rohre per Code.

### So führen Sie das aus:
1.  Kopieren Sie den untenstehenden 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 sie 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>
        // --- 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 sich 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 Fliegen über 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;

                    // Kollisionsabfrage
                    // Logik: Prüfe, ob die X-Position des Vogels im Rohr-X-Bereich liegt
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // Logik: Prüfe, 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();
                        }
                    }

                    // Punkteaktualisierung (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"; // Rasen-Grün
                ctx.fillRect(0, canvas.height - 20, canvas.width, 20);
                ctx.beginPath();
                ctx.moveTo(0, canvas.height - 20);
                ctx.lineTo(canvas.width, canvas.height - 20);
                ctx.stroke();
            }
        };

        // --- Spiel-Steuerfunktionen ---

        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 keine Frames oder Positionen, einfrieren
            }

            requestAnimationFrame(loop);
        }

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

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

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

        // --- Eingabeverarbeitung ---

        function handleInput(e) {
            // Verhindere das Standard-Scroll-Verhalten für die 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);

        // Initialisierung
        loop();

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

### Funktionen in dieser Version:
1.  **Physik:** Realistische Schwerkraft und Sprungmechanik.
2.  **Kollisionsabfrage:** 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 Ihre beste Punktzahl zu speichern, auch wenn Sie die Seite aktualisieren.
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 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 unserem Leitfaden folgen. Ändern Sie einfach den Modellnamen 'GLM-4.7-Flash' in 'Qwen3-Coder-Next' und stellen Sie sicher, dass Sie die korrekten Qwen3-Coder-Next-Parameter und Gebrauchsanweisungen befolgen. Verwenden Sie das llama-server das wir gerade eingerichtet haben.

Claude Code

OpenAI Codex

Nachdem Sie beispielsweise die Anweisungen für Claude Code befolgt haben, werden Sie Folgendes sehen:

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

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}} dann 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 unser neues FP8 dynamische 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, wenn Sie es nicht haben, für schnellere Umgebungs-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

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 starten Sie den Dienst Unsloths dynamische FP8-Version Unsloths dynamische FP8-Version --kv-cache-dtype fp8 --kv-cache-dtype fp8 CUDA_VISIBLE_DEVICES='0' und setzen Sie --tensor-parallel-size 1 --tensor-parallel-size 1 tmux oder entfernen Sie dieses Argument. Verwenden Sie um das Folgende in einem neuen Terminal zu starten und dann CTRL+B+D - verwenden Sie tmux attach-session -t0

export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
    CUDA_VISIBLE_DEVICES='0,1,2,3' vllm serve unsloth/Qwen3-Coder-Next-FP8-Dynamic \
    --tensor-parallel-size 4 \
    --tensor-parallel-size 4 \
    --enable-auto-tool-choice \
    --dtype bfloat16 \
    --seed 3407 \
    --max-model-len 200000 \
    --max-model-len 200000 \
    --gpu-memory-utilization 0.93 \

--port 8001 Qwen3-Coder-Next wie man Qwen3-Coder-Next tatsächlich mit der OpenAI-API und Tool-Aufrufen 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, Ausführen von Python-Code, 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 Galaxis...",
        "Es gab zwei Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil jedes Faultier eine übermenschliche Intelligenz entwickelte...",
        "Ohne dass ein Freund es wusste, 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 'rm, sudo, dd, chmod'-Befehle 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 aus dem 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 untenstehenden 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-Aufrufen für viele verschiedene Anwendungsfälle unten:

Ausführen 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 Terminalbefehle

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 wurde sie!

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

📐Benchmarks

GGUF-Quantisierungs-Benchmarks

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

Aider Polyglot Benchmarks

Benjamine Marie Benchmarks (Quelle)

Die Benchmarks wurden von Drittbeiträgen auf dem Aider Polyglot-Server durchgeführt und verglichen Unsloth GGUF-Quantisierungen auf dem 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 sinnvolles Minimum für die meisten Anwendungsfälle ist.

NVFP4 übertrifft die BF16-Referenz leicht, was auf Stichprobenrauschen durch eingeschränkte Durchläufe zurückzuführen sein kann; das allgemeine Muster für: 1-Bit → 2-Bit → 3-Bit → 6-Bit stetige Verbesserung legt nahe, dass der Benchmark aussagekräftige Qualitätsunterschiede zwischen Unsloth-GGUFs erfasst. Das nicht-Unsloth FP8 scheint schlechter abzuschneiden als beide UD-IQ3_XXS und UD-Q6_K_XL, was Unterschiede in der Quantisierungspipeline widerspiegeln könnte oder wiederum auf unzureichende Stichprobengröße hindeutet.

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

Die Grafiken zeigen deutlich, dass die Unsloth Q4_K_M-Quants besser abschneiden als Standard Q4_K_M. Q3_K_M schneidet erwartungsgemäß schlechter im Live Code Bench v6 ab, überraschenderweise jedoch deutlich besser bei HumanEval als das Standard Q4_K_M. Es scheint am effizientesten zu laufen; es wird empfohlen, mindestens Q4_K_M zu verwenden.

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