🌠Qwen3-Coder-Next : comment l’exécuter localement

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

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

Il fonctionne avec 46 Go de RAM/VRAM/mémoire unifiée (85 Go pour 8 bits), est sans raisonnement pour des réponses de code ultra-rapides. Le modèle excelle dans le raisonnement à long horizon, l'utilisation complexe d'outils et la récupération après des échecs d'exécution.

Mise à jour du 19 févr.: l'appel d'outils devrait maintenant être encore meilleur après les corrections d'analyse de llama.cpp.

NOUVEAU ! Voir benchmarks de quantification pour nos Dynamic GGUF !

4 févr. : llama.cpp corrigé un bug qui rectifie le calcul pour key_gdiff vectorisé. Cela corrige les problèmes précédents de boucle et de sortie. Nous avons mis à jour les GGUF - veuillez retélécharger et MISE À JOUR llama.cpp pour de meilleures sorties.

Vous apprendrez également à exécuter le modèle sur Codex et Claude Code. Pour ajustement fin, Qwen3-Next-Coder tient sur un seul GPU B200 pour du LoRA bf16 dans Unsloth.

Unsloth Qwen3-Coder-Next Dynamic GGUF à exécuter : unsloth/Qwen3-Coder-Next-GGUF

Tutoriel d'exécution GGUF Codex et Claude Code Tutoriel FP8 vLLM

⚙️ Guide d'utilisation

Vous n'avez pas 46 Go de RAM ou de mémoire unifiée ? Pas de souci, vous pouvez exécuter nos quants plus petits comme le 3 bits. Il est préférable que la taille du modèle soit = à la somme de vos ressources ( espace disque + RAM + VRAM ≥ taille du quant). Si votre quant tient entièrement sur votre appareil, attendez-vous à 20+ jetons/s. S'il ne tient pas, il fonctionnera quand même en déchargeant des éléments, 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 de contexte en natif, mais vous pouvez le définir à 32,768 jetons pour réduire l'utilisation de la mémoire.

🖥️ Exécuter Qwen3-Coder-Next

Selon votre cas d'utilisation, vous devrez utiliser différents réglages. 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.

🦥 Guide d'Unsloth Studio

Qwen3-Coder-Next peut être exécuté et ajusté dans Unsloth Studio, notre nouvelle interface web open source pour l’IA locale. Avec Unsloth Studio, vous pouvez exécuter des modèles localement sur MacOS, Windows, Linux et :

Rechercher, télécharger, exécuter des GGUF et des modèles safetensor
Auto-réparation appel d'outils + recherche web
Exécution de code (Python, Bash)
Inférence automatique réglage des paramètres (temp, top-p, etc.)
Inférence rapide sur CPU + GPU via llama.cpp
Entraîner des LLM 2x plus rapide avec 70 % de VRAM en moins

Installer Unsloth

Exécutez dans votre terminal :

macOS, Linux, WSL :

curl -fsSL https://unsloth.ai/install.sh | sh

Windows PowerShell :

irm https://unsloth.ai/install.ps1 | iex

L'installation sera rapide et prendra environ 1 à 2 minutes.

Lancer Unsloth

MacOS, Linux, WSL et Windows :

unsloth studio -H 0.0.0.0 -p 8888

Puis ouvrez http://localhost:8888 dans votre navigateur.

Rechercher et télécharger Qwen3-Coder-Next

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d'intégration pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez l'ignorer à tout moment et aller directement au chat.

Puis allez dans l’onglet Unsloth Chat onglet et recherchez Qwen3-Coder-Next dans la barre de recherche et téléchargez le modèle et le quant de votre choix.

Exécuter Qwen3-Coder-Next

Les paramètres d'inférence doivent être définis automatiquement lors de l'utilisation d'Unsloth Studio ; toutefois, vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur de contexte, le gabarit de conversation et d'autres paramètres.

Pour plus d'informations, vous pouvez consulter notre Guide d'inférence Unsloth Studio.

Tutoriel Llama.cpp (GGUF) :

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

Obtenez la dernière version de llama.cpp sur GitHub ici. Vous pouvez également suivre les instructions de compilation ci-dessous. Remplacez -DGGML_CUDA=ON par -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence sur CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez comme d'habitude - la prise en charge de Metal est activée par défaut.

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

Vous pouvez directement le récupérer depuis Hugging Face. Vous pouvez augmenter le contexte à 256K si votre RAM/VRAM peut le contenir. L'utilisation de --fit on déterminera également 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

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 restent bloqués, voir Dépannage de Hugging Face Hub et 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*"

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 également la fenêtre de contexte si nécessaire, jusqu'à 262,144

REMARQUE : Ce modèle ne prend en charge que le mode sans réflexion et ne génère pas <think></think> de blocs dans sa sortie. Donc préciser enable_thinking=False n'est plus nécessaire.

🦙 Diffusion et déploiement de Llama-server

Pour déployer Qwen3-Coder-Next en production, nous utilisons llama-server Dans un nouveau terminal, par exemple via tmux. Puis, 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": "Créer un jeu Flappy Bird en 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 les graphismes et **JavaScript** pour la physique (gravité, détection des collisions et score). Aucune image externe ni aucun téléchargement ne sont nécessaires ; le jeu dessine l'oiseau et les tuyaux à l'aide de code.

### Comment l'exécuter :
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 travers vers le 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>Espace</strong> ou <strong>Cliquez</strong> pour sauter</p>
                <p>Appuyez sur Espace pour commencer</p>
            </div>
            <div id="game-over-screen" class="message" style="display: none;">
                <h2>Fin de partie</h2>
                <p>Score : <span id="final-score">0</span></p>
                <p>Meilleur : <span id="best-score">0</span></p>
                <p>Appuyez sur <strong>Espace</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 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();

                // Œil
                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 (facultatif : empêche de survoler les 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 du haut et celui du 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 du haut
                    ctx.fillRect(p.x, 0, this.width, topY);
                    ctx.strokeRect(p.x, 0, this.width, topY);

                    // Tuyau du bas
                    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 images (environ 2 secondes)
                if (frames % 120 === 0) {
                    // Hauteur aléatoire pour le tuyau du haut
                    // 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 des collisions
                    // Logique : vérifier si l'X de l'oiseau se trouve dans l'intervalle X du tuyau
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // Logique : vérifier si l'Y de l'oiseau touche le tuyau du haut OU du bas
                        if (bird.y < p.y || bird.y + bird.height > p.y + this.gap) {
                            gameOver();
                        }
                    }

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

                    // Supprimer les tuyaux qui sont 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 pelouse
                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 images ni la position, geler simplement
            }

            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 Espace
            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);

        // Initialisation
        loop();

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

### Fonctionnalités de cette version :
1.  **Physique :** Gravité réaliste et mécanique de saut.
2.  **Détection des collisions :** La partie se termine si vous touchez les tuyaux, le sol ou le plafond.
3.  **Système de score :** Vous obtenez 1 point pour chaque tuyau franchi.
4.  **Meilleur score :** Utilise le LocalStorage de votre navigateur pour mémoriser votre meilleur score même si vous actualisez la page.
5.  **Commandes réactives :** Fonctionne avec la **barre d'espace**, le **clic de souris** ou le **toucher** (pour les appareils mobiles).
6.  **Graphismes :** L'oiseau est dessiné par le code (y compris un œil et un bec) et les tuyaux ont des bordures, donc aucun lien d'image cassé ne se produira.

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 et Claude Code

Pour exécuter le modèle via des charges de travail agentiques de codage locales, vous pouvez suivre notre guide. Utilisez la llama-server que nous venons de configurer à l’instant, et définissez le nom du modèle sur l’identifiant exact qu’il renvoie à GET /v1/models (la --alias valeur ci-dessus, unsloth/Qwen3-Coder-Next). Suivez les paramètres et les instructions d'utilisation corrects de Qwen3-Coder-Next.

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 d’échecs en Python :

Si vous voyez Erreur API : 400 {"error":{"code":400,"message":"la requête (16582 jetons) dépasse la taille de contexte disponible (16384 jetons), essayez de l'augmenter","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 maintenant utiliser notre nouveau quant FP8 dynamique du modèle pour une inférence premium et rapide. Installez d'abord vLLM depuis la version nightly. Changez --extra-index-url https://wheels.vllm.ai/nightly/cu130 à votre version de CUDA trouvée via nvidia-smi - uniquement cu129 et cu130 sont actuellement pris en charge.

Si vous utilisez vLLM / SGLang, essayez nos quants FP8 dynamiques, 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

Puis servez la version FP8 dynamique d'Unsloth du modèle. Vous pouvez également activer FP8 pour réduire de 50 % l'utilisation de la mémoire du cache KV en ajoutant --kv-cache-dtype fp8 Nous l'avons servi sur 4 GPU, mais si vous n'avez qu'un seul 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 l'appel d'outils - cela fonctionne pour vLLM et llama-server.

🔧Appel d'outils avec Qwen3-Coder-Next

Dans un nouveau terminal, nous créons quelques outils comme additionner 2 nombres, exécuter du code Python, exécuter des fonctions Linux et bien plus encore :

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 subtract_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 très très lointaine...",
        "Il y avait 2 amis qui aimaient les paresseux et le code...",
        "Le monde prenait fin parce que chaque paresseux avait évolué pour avoir une intelligence surhumaine...",
        "À l'insu de l'un des amis, 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 de 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"La commande a échoué : {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,
    "subtract_number": subtract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Additionne 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": "Multiplie 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": "subtract_number",
            "description": "Soustrait 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": "Effectue des opérations depuis le terminal.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "La commande que vous souhaitez lancer, par ex. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Appelle 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 (copier-coller et exécuter), qui analyseront automatiquement les appels de fonction 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"Using model = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Current messages = {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 ci-dessous plusieurs méthodes d’exécution de l’appel d’outils pour de nombreux cas d’usage différents :

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

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

Exécuter des fonctions de terminal arbitraires

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Écrivez 'I'm a happy Sloth' dans un fichier, puis imprimez-le-moi."}],
}]
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 bien le cas !

Voir Tool Calling Guide pour plus d’exemples d’appel d’outils.

📐Benchmarks

Benchmarks de quantification GGUF

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

Les benchmarks ont été exécutés par des contributeurs tiers sur le serveur Aider Polyglot, comparant les quantifications GGUF d’Unsloth sur le benchmark Aider Polyglot (score vs. VRAM). À noter, la quantification 3 bits UD-IQ3_XXS se rapproche de BF16 les performances, ce qui fait que 3 bits constituent un minimum raisonnable pour la plupart des cas d’usage.

NVFP4 surpasse légèrement la référence BF16, ce qui peut être du bruit d’échantillonnage en raison du nombre limité d’exécutions ; cependant, la tendance globale pour : 1-bit → 2-bit → 3-bit → 6-bit en s’améliorant régulièrement, suggère que le benchmark capture des différences de qualité significatives entre les GGUF d’Unsloth. Le non-Unsloth FP8 semble moins bien performer 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, là encore, un échantillonnage insuffisant.

Benjamin Marie (tiers) a évalué Qwen3-Coder-Next en utilisant Unsloth et des GGUF Qwen sur un suite mixte de 750 invites (LiveCodeBench v6, MMLU Pro, GPQA, Math500), en rapportant à la fois la précision globale et l'augmentation relative de l'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 obtiennent de meilleurs résultats que le Q4_K_M standard. Comme prévu, Q3_K_M obtient de moins bons résultats sur Live Code Bench v6, mais, contre toute attente, bien meilleurs sur HumanEval que le Q4_K_M standard. Il semble fonctionner avec la plus grande efficacité ; il est conseillé d’utiliser au moins Q4_K_M.

Benchmarks 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 ayant 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 Verified (avec SWE-Agent)

70.6

70.2

74.2

74.8

SWE-Bench Multilingual (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

Mis à jour il y a 4 jours

Ce contenu vous a-t-il été utile ?