🌠Qwen3-Coder-Next : Comment exécuter localement

Guide pour exécuter Qwen3-Coder-Next localement sur votre appareil !

Qwen publie Qwen3-Coder-Next, un modèle MoE de 80B (3B paramètres actifs) avec contexte 256K pour un codage agentique rapide et une utilisation locale. Il est comparable aux performances de modèles avec 10–20× plus de paramètres actifs.

Il fonctionne sur 46 Go de RAM/VRAM/mémoire unifiée (85 Go pour 8 bits), est en mode non-réflexion pour des réponses de code ultra-rapides. Le modèle excelle en raisonnement à long terme, en utilisation d'outils complexes et en récupération après des échecs d'exécution.

Mise à jour du 19 fév. : L'appel d'outils devrait maintenant être encore meilleur après que llama.cpp ait corrigé l'analyse.

NOUVEAU ! Voir benchmarks de quantification pour nos GGUF dynamiques !

4 fév. : llama.cpp a corrigé un bug qui ajustait le calcul pour vectorized key_gdiff. Cela corrige les boucles et les problèmes de sortie précédents. Nous avons mis à jour les GGUF - veuillez retélécharger et METTRE À JOUR llama.cpp pour de meilleures sorties.

Vous apprendrez aussi à exécuter le modèle sur Codex & Claude Code. Pour l'affinage, Qwen3-Next-Coder tient sur un seul GPU B200 pour LoRA bf16 dans Unsloth.

Qwen3-Coder-Next Unsloth GGUFs dynamiques pour exécuter : unsloth/Qwen3-Coder-Next-GGUF

Tutoriel Run GGUFCodex & Claude CodeTutoriel FP8 vLLM

⚙️ Guide d'utilisation

Vous n'avez pas 46 Go de RAM ou de mémoire unifiée ? Pas de souci, vous pouvez utiliser nos quantifications plus petites comme 3 bits. Il est préférable que la taille du modèle soit égale à la somme de votre calcul ( espace disque + RAM + VRAM ≥ taille de la quantification). Si votre quantification tient entièrement sur votre appareil, attendez-vous à 20+ tokens/s. Si elle ne tient pas, elle fonctionnera toujours en déchargeant mais ce sera plus lent.

Pour obtenir des performances optimales, Qwen recommande ces réglages :

• Température = 1.0

• Top_P = 0.95

• Top_K = 40

• Min_P = 0.01 (la valeur par défaut de llama.cpp est 0.05)

• pénalité de répétition = désactivée ou 1.0

Prend en charge jusqu'à 262,144 contexte nativement mais vous pouvez le régler sur 32,768 tokens pour une utilisation mémoire réduite.

🖥️ Exécuter Qwen3-Coder-Next

Selon votre cas d'utilisation, vous devrez utiliser des réglages différents. Comme ce guide utilise du 4 bits, vous aurez besoin d'environ 46 Go de RAM/mémoire unifiée. Nous recommandons d'utiliser au moins une précision 3 bits pour de meilleures performances.

Mise à jour du 4 fév. : llama.cpp a corrigé un bug qui ajustait le calcul pour vectorized key_gdiff. Cela corrige les boucles et les problèmes de sortie précédents. Nous avons mis à jour les GGUF - veuillez retélécharger et METTRE À JOUR llama.cpp pour de meilleures sorties.

REMARQUE : Ce modèle prend en charge uniquement le mode non-pensée et ne génère pas <think></think> blocs dans sa sortie. Donc spécifier enable_thinking=False n'est plus requis.

Tutoriel Llama.cpp (GGUF) :

Instructions pour exécuter dans llama.cpp (notez que nous utiliserons du 4 bits pour tenir sur la plupart des appareils) :

1

Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez aussi suivre les instructions de compilation ci-dessous. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU.

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

Vous pouvez directement récupérer depuis Hugging Face. Vous pouvez augmenter le contexte à 256K si votre RAM/VRAM le permet. L'utilisation de --fit on déterminera aussi automatiquement la longueur du contexte.

Vous pouvez utiliser les paramètres recommandés : 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

Téléchargez le modèle via (après avoir installé pip install huggingface_hub). Vous pouvez choisir UD-Q4_K_XL ou d'autres versions quantifiées. Si les téléchargements se bloquent, voyez Hugging Face Hub, débogage XET

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

Ensuite, exécutez le modèle en mode conversation :

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

Ajustez aussi fenêtre de contexte selon les besoins, jusqu'à 262,144

REMARQUE : Ce modèle prend en charge uniquement le mode non-pensée et ne génère pas <think></think> blocs dans sa sortie. Donc spécifier enable_thinking=False n'est plus requis.

🦙Service et déploiement llama-server

Pour déployer Qwen3-Coder-Next en production, nous utilisons llama-server Dans un nouveau terminal, par exemple via tmux. Ensuite, déployez le modèle via :

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

Puis dans un nouveau terminal, après avoir fait pip install openai, nous pouvons exécuter le modèle :

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)

Ce qui produira :

Voici un jeu Flappy Bird complet et fonctionnel contenu dans un seul fichier.

J'ai utilisé **HTML5 Canvas** pour le graphisme et **JavaScript** pour la physique (gravité, détection de collision et comptage des points). Aucune image externe ni téléchargement n'est requis ; le jeu dessine l'oiseau et les tuyaux par le code.

### Comment exécuter ceci :
1.  Copiez le bloc de code ci-dessous.
2.  Créez un nouveau fichier sur votre ordinateur nommé `game.html`.
3.  Collez le code dans ce fichier et enregistrez-le.
4.  Double-cliquez sur `game.html` pour l'ouvrir dans votre navigateur web.

```html
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flappy Bird Simple</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; /* Bleu ciel */
            border: 4px solid #000;
        }

        #ui-layer {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none; /* Laisser les clics passer au 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>Clone de Flappy Bird</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>Prêt à voler ?</h2>
                <p>Appuyez sur <strong>Space</strong> ou <strong>Cliquez</strong> pour sauter</p>
                <p>Appuyez sur Space pour démarrer</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>Meilleur : <span id="best-score">0</span></p>
                <p>Appuyez sur <strong>Space</strong> pour recommencer</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');

        // Variables du jeu
        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; // Vitesse de déplacement des tuyaux vers la gauche

        // --- L'objet Oiseau ---
        const bird = {
            x: 50,
            y: 150,
            width: 30,
            height: 30,
            velocity: 0,
            jumpStrength: 4.5,
            radius: 15,
            draw: function() {
                ctx.fillStyle = "#FFD700"; // Couleur or
                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();

                // Oeil
                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();
                
                // Bec
                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;

                // Collision avec le sol
                if (this.y + this.height >= canvas.height) {
                    this.y = canvas.height - this.height;
                    gameOver();
                }
                
                // Collision avec le plafond (Optionnel : empêche de voler au-dessus des tuyaux)
                if (this.y < 0) {
                    this.y = 0;
                    this.velocity = 0;
                }
            },
            jump: function() {
                this.velocity = -this.jumpStrength;
            },
            reset: function() {
                this.y = 150;
                this.velocity = 0;
            }
        };

        // --- Le tableau des tuyaux ---
        const pipes = {
            position: [],
            width: 50,
            gap: 120, // Espace entre le tuyau haut et bas
            dx: 2, // Vitesse de déplacement

            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"; // Vert forêt

                    // Tuyau supérieur
                    ctx.fillRect(p.x, 0, this.width, topY);
                    ctx.strokeRect(p.x, 0, this.width, topY);

                    // Tuyau inférieur
                    ctx.fillRect(p.x, bottomY, this.width, canvas.height - bottomY);
                    ctx.strokeRect(p.x, bottomY, this.width, canvas.height - bottomY);
                }
            },

            update: function() {
                // Ajouter un nouveau tuyau toutes les 120 frames (environ 2 secondes)
                if (frames % 120 === 0) {
                    // Hauteur aléatoire pour le tuyau supérieur
                    // Hauteur min 50, Hauteur max 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;

                    // Détection de collision
                    // Logique : vérifier si l'axe X de l'oiseau est dans la plage X du tuyau
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // Logique : vérifier si l'axe Y de l'oiseau touche le tuyau supérieur OU le tuyau inférieur
                        if (bird.y < p.y || bird.y + bird.height > p.y + this.gap) {
                            gameOver();
                        }
                    }

                    // Mise à jour du score (quand l'oiseau passe le tuyau)
                    if (p.x + this.width < bird.x && !p.passed) {
                        score++;
                        scoreElement.innerText = score;
                        p.passed = true;
                    }

                    // Supprimer les tuyaux sortis de l'écran
                    if (p.x + this.width <= 0) {
                        this.position.shift();
                        // Décrémenter i car la longueur du tableau a changé
                        i--; 
                    }
                }
            },
            
            reset: function() {
                this.position = [];
            }
        };

        // --- Arrière-plan (nuages/herbe) ---
        const background = {
            draw: function() {
                // Dessiner l'herbe
                ctx.fillStyle = "#7cfc00"; // Vert gazon
                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();
            }
        };

        // --- Fonctions de contrôle du jeu ---

        function loop() {
            // Effacer le canvas
            ctx.clearRect(0, 0, canvas.width, canvas.height);

            // Dessiner l'arrière-plan
            background.draw();

            if (gameState === 'START') {
                bird.draw();
                // Dessiner une ligne de sol
                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();
                // Ne pas mettre à jour les frames ou la position, juste geler
            }

            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';
            
            // Mettre à jour le meilleur score
            if (score > highScore) {
                highScore = score;
                localStorage.setItem('flappyHighScore', highScore);
            }

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

        // --- Gestion des entrées ---

        function handleInput(e) {
            // Empêcher le défilement par défaut pour la touche 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);

        // Initialiser
        loop();

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

### Fonctions de cette version :
1.  **Physique :** Gravité réaliste et mécaniques de saut.
2.  **Détection de collision :** Le jeu se termine si vous heurtez les tuyaux, le sol ou le plafond.
3.  **Système de score :** Vous gagnez 1 point pour chaque tuyau passé.
4.  **Meilleur score :** Utilise le LocalStorage de votre navigateur pour mémoriser votre meilleur score même si vous actualisez la page.
5.  **Contrôles réactifs :** Fonctionne avec la **barre d'espace**, le **clic de souris** ou le **touch** (pour mobile).
6.  **Graphismes :** L'oiseau est dessiné par le code (incluant un œil et un bec) et les tuyaux ont des bordures, donc aucun lien d'image cassé ne surviendra.

Nous avons extrait le HTML et l'avons exécuté, et l'exemple de jeu Flappy Bird qu'il a généré a bien fonctionné !

👾 OpenAI Codex & Claude Code

Pour exécuter le modèle via des charges de travail agentiques locales de codage, vous pouvez suivre notre guide. Il suffit de changer le nom du modèle 'GLM-4.7-Flash' en 'Qwen3-Coder-Next' et de vous assurer de suivre les paramètres et instructions d'utilisation corrects de Qwen3-Coder-Next. Utilisez le llama-server que nous venons de configurer à l'instant.

Claude Code

OpenAI Codex

Après avoir suivi les instructions pour Claude Code par exemple, vous verrez :

Nous pouvons alors demander par exemple Créer un jeu Python d'échecs :

Si vous voyez 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}} cela signifie que vous devez augmenter la longueur du contexte ou voir Qwen3-Coder-Next

🎱 FP8 Qwen3-Coder-Next dans vLLM

Vous pouvez désormais utiliser notre nouveau quant FP8 dynamique du modèle pour une inférence premium et rapide. Installez d'abord vLLM depuis les nightly. Changez --extra-index-url https://wheels.vllm.ai/nightly/cu130 en fonction de votre version CUDA trouvée via nvidia-smi - seulement cu129 et cu130 sont actuellement pris en charge.

Si vous utilisez vLLM / SGLang, essayez d'utiliser nos quants FP8-Dynamic qui peuvent augmenter le débit de 25 % ou plus ! Voir Qwen3-Coder-Next

# Installez uv si vous ne l'avez pas pour des installations d'environnement plus rapides
curl -LsSf https://astral.sh/uv/install.sh | sh

# Créez un nouvel environnement Python - pas nécessaire si vous voulez modifier tout votre système
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

Ensuite servez Version FP8 dynamique d'Unsloth du modèle. Vous pouvez également activer FP8 pour réduire l'utilisation de la mémoire du cache KV de 50 % en ajoutant --kv-cache-dtype fp8 Nous l'avons servi sur 4 GPU, mais si vous n'avez qu'un GPU, utilisez CUDA_VISIBLE_DEVICES='0' et définissez --tensor-parallel-size 1 ou supprimez cet argument. Utilisez tmux pour lancer ce qui suit dans un nouveau terminal puis CTRL+B+D - utilisez tmux attach-session -t0 pour y revenir.

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

Vous devriez voir quelque chose comme ci-dessous. Voir Qwen3-Coder-Next pour savoir comment utiliser réellement Qwen3-Coder-Next avec l'API OpenAI et les appels d'outils - cela fonctionne pour vLLM et llama-server.

🔧Appels d'outils avec Qwen3-Coder-Next

Dans un nouveau terminal, nous créons quelques outils comme l'addition de 2 nombres, l'exécution de code Python, l'exécution de fonctions Linux et bien plus :

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([
        "Il y a bien longtemps dans une galaxie lointaine...",
        "Il y avait 2 amis qui aimaient les paresseux et le code...",
        "Le monde était en train de finir parce que chaque paresseux avait évolué vers une intelligence surhumaine...",
        "À l'insu d'un ami, l'autre a accidentellement codé un programme pour faire évoluer les paresseux...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Impossible d'exécuter les commandes 'rm, sudo, dd, chmod' car elles sont dangereuses"
        print(msg); return msg
    print(f"Exécution de la commande terminal `{command}`")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Échec de la commande : {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": "Ajouter deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "Multiplier deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "substract_number",
            "description": "Soustraire deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "Écrit une histoire aléatoire.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Effectuer des opérations depuis le terminal.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "La commande que vous souhaitez lancer, ex. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Appeler un interpréteur Python avec du code Python qui sera exécuté.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Le code Python à exécuter",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

Nous utilisons ensuite les fonctions ci-dessous (copiez-collez et exécutez) qui analyseront automatiquement les appels de fonctions et appelleront le point de terminaison OpenAI pour n'importe quel modèle :

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"Utilisation du modèle = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Messages actuels = {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

Nous allons maintenant présenter plusieurs méthodes d'exécution d'appels d'outils pour de nombreux cas d'utilisation ci-dessous :

Exécuter du code Python généré

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Créer une fonction Fibonacci en Python et trouver fib(20)."}],
}]
unsloth_inference(messages, temperature = 1.0, top_p = 0.95, top_k = 40, min_p = 0.00)

Exécuter des fonctions arbitraires du terminal

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Écrire 'I'm a happy Sloth' dans un fichier, puis me l'imprimer."}],
}]
messages = unsloth_inference(messages, temperature = 1.0, top_p = 1.0, top_k = 40, min_p = 0.00)

Nous confirmons que le fichier a été créé, et c'est le cas !

Voir Tool Calling Guide pour plus d'exemples d'appels d'outils.

📐Benchmarks

Benchmarks de quantification GGUF

Voici quelques benchmarks de quantification réalisés par des évaluateurs tiers.

Benchmarks Aider Polyglot

Benchmarks de Benjamine Marie (Source)

Les benchmarks ont été exécutés par des contributeurs tiers sur le serveur Aider Polyglot, comparant les quantifications Unsloth GGUF sur le benchmark Aider Polyglot (score vs. VRAM). Notamment, la quantification 3 bits UD-IQ3_XXS se rapproche de BF16 en termes de performance, faisant des 3 bits un minimum judicieux pour la plupart des cas d'utilisation.

NVFP4 surpasse légèrement la référence BF16, ce qui peut être du bruit d'échantillonnage dû à un nombre limité d'exécutions ; cependant, le schéma global pour : 1-bit → 2-bit → 3-bit → 6-bit s'améliorant progressivement, suggère que le benchmark capture des différences de qualité significatives entre les GGUF d'Unsloth. Le non-Unsloth FP8 semble performer moins bien que les deux UD-IQ3_XXS et UD-Q6_K_XL, ce qui pourrait refléter des différences dans la chaîne de quantification ou, encore une fois, un échantillonnage insuffisant.

Benjamin Marie (tiers) a évalué Qwen3-Coder-Next en utilisant les GGUF Unsloth et Qwen sur une suite mixte de 750 invites (LiveCodeBench v6, MMLU Pro, GPQA, Math500), rapportant à la fois la précision globale et l'augmentation relative d'erreur (à quelle fréquence le modèle quantifié fait des erreurs par rapport à l'original).

Les graphiques montrent clairement que les quantifications Q4_K_M d'Unsloth offrent de meilleures performances que le Q4_K_M standard. Q3_K_M fonctionne comme prévu moins bien sur Live Code Bench v6, mais étonnamment bien mieux sur HumanEval que le Q4_K_M standard. Il semble fonctionner avec la plus grande efficacité, l'utilisation d'au moins Q4_K_M est conseillée.

Benchmarks de Qwen3-Coder-Next

Qwen3-Coder-Next est le modèle le plus performant pour sa taille, et ses performances sont comparables à celles de modèles avec 10–20× plus de paramètres actifs.

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