🌠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 agentif rapide et une utilisation locale. Il est comparable aux performances de modèles ayant 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, utilisation complexe d'outils et récupération après des échecs d'exécution.

Mise à jour du 4 févr. : llama.cpp correction d'un bug dans le calcul de key_gdiff vectorisé. Cela corrige des problèmes de bouclage et de sortie précédents. Nous avons mis à jour les GGUF - veuillez retélécharger et MISE À JOUR llama.cpp pour de meilleurs résultats.

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

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

Tutoriel exécution 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 exécuter nos quantifications plus petites comme 3 bits. Il est préférable que la taille du modèle = la somme de votre capacité de 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, cela fonctionnera toujours en déchargeant mais ce sera plus lent.

Pour obtenir des performances optimales, Qwen recommande ces paramètres :

• 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 définir sur 32,768 tokens pour moins d'utilisation de mémoire.

🖥️ Exécuter Qwen3-Coder-Next

Selon votre cas d'utilisation, vous devrez utiliser des paramètres 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 la précision 3 bits pour de meilleures performances.

Mise à jour du 4 févr. : llama.cpp correction d'un bug dans le calcul de key_gdiff vectorisé. Cela corrige des problèmes de bouclage et de sortie précédents. Nous avons mis à jour les GGUF - veuillez retélécharger et MISE À JOUR llama.cpp pour de meilleurs résultats.

REMARQUE : Ce modèle ne supporte que le mode non-pensée et ne génère pas <think></think> blocs dans sa sortie. Donc en spécifiant 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 suivre les instructions de compilation ci-dessous également. 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 peut le contenir. L'utilisation de --fit on déterminera aussi automatiquement la longueur du contexte.

Vous pouvez utiliser les paramètres recommandés : temperature=1.0, temperature=0.6, 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.

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 également fenêtre de contexte au besoin, jusqu'à 262,144

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

🦙Service & déploiement 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éez 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 de collision et score). Aucune image externe ou téléchargement requis ; le jeu dessine l'oiseau et les tuyaux via du 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="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; /* 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>Espace</strong> ou <strong>Cliquez</strong> pour Sauter</p>
                <p>Appuyez sur Espace pour démarrer</p>
            </div>
            <div id="game-over-screen" class="message" style="display: none;">
                <h2>Fin de la 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 de déplacement des tuyaux vers la gauche

        // --- L'objet Bird ---
        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 supérieur et inférieur
            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 (env. 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 la position 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 la position Y de l'oiseau touche le tuyau supérieur OU inférieur
                        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;
                    }

                    // Retirer 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 frames ou 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 comportement de 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);

        // Initialiser
        loop();

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

### Fonctionnalités de cette version :
1.  **Physique :** Gravité réaliste et mécanique 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 que vous dépassez.
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 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 brisé ne surviendra.

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

👾 OpenAI Codex & Claude Code

Pour exécuter le modèle via des charges de travail agentives de codage locales, vous pouvez suivre notre guide. Changez simplement le nom du modèle 'GLM-4.7-Flash' en 'Qwen3-Coder-Next' et assurez-vous de suivre les bons paramètres et instructions d'utilisation 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éez un jeu Python pour les échecs :

Si vous voyez Erreur API : 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 📐Comment adapter un long contexte

🎱 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 pour votre version CUDA trouvée via nvidia-smi - uniquement cu129 et cu130 sont actuellement pris en charge.

# 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 changer 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 La version FP8 dynamique d'Unsloth du modèle. Vous pouvez aussi activer FP8 pour réduire l'utilisation mémoire du cache KV de 50% en ajoutant --kv-cache-dtype fp8 Nous l'avons servi sur 4 GPU, mais si vous avez 1 GPU, utilisez CUDA_VISIBLE_DEVICES='0' et définir --tensor-parallel-size 1 ou retirez 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 comment utiliser réellement Qwen3-Coder-Next via 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 l'addition de 2 nombres, l'exécution de code Python, l'exécution de 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 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 adoraient les paresseux et le code...",
        "Le monde était en train de finir parce que chaque paresseux avait évolué pour avoir 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": "Additionne deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le second 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 second nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "substract_number",
            "description": "Soustrait deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le second 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, 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 (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é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 arbitraires du terminal

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Écris 'I'm a happy Sloth' dans un fichier, puis affiche-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 le cas !

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

🛠️ Améliorer la vitesse de génération

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

Si vous avez plus de VRAM, vous pouvez essayer de décharger plus de couches MoE, ou de décharger des couches complètes elles-mêmes.

Normalement, -ot ".ffn_.*_exps.=CPU" décharge toutes les couches MoE vers le CPU ! Cela vous permet effectivement de faire tenir toutes les couches non-MoE sur 1 GPU, améliorant les vitesses de génération. Vous pouvez personnaliser l'expression regex pour décharger plus de couches si vous disposez de plus de capacité GPU.

Si vous avez un peu plus de mémoire GPU, essayez -ot ".ffn_(up|down)_exps.=CPU" Cela décharge les couches MoE de projection up et down.

Essayez -ot ".ffn_(up)_exps.=CPU" si vous avez encore plus de mémoire GPU. Cela ne décharge que les couches MoE de projection up.

Vous pouvez aussi personnaliser le regex, par exemple -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" signifie décharger les couches MoE gate, up et down mais seulement à partir de la 6e couche.

Le dernière version de llama.cpp introduit également le mode haut débit. Utilisez llama-parallel. Lisez-en davantage ici. Vous pouvez aussi quantifier le cache KV en 4 bits par exemple pour réduire les mouvements de VRAM / RAM, ce qui peut aussi accélérer le processus de génération. Le prochain section parle de la quantification du cache KV.

📐Comment adapter un long contexte

Pour adapter un contexte plus long, vous pouvez utiliser la quantification du cache KV pour quantifier les caches K et V en moins de bits. Cela peut aussi augmenter la vitesse de génération en réduisant les mouvements de données RAM / VRAM. Les options autorisées pour la quantification K (par défaut est f16) incluent ci-dessous.

--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1

Vous devriez utiliser les _1 variantes pour une précision quelque peu accrue, bien que ce soit légèrement plus lent. Par ex. q4_1, q5_1 Donc essayez --cache-type-k q4_1

Vous pouvez aussi quantifier le cache V, mais vous devrez compiler llama.cpp avec le support Flash Attention via -DGGML_CUDA_FA_ALL_QUANTS=ON, et utiliser --flash-attn pour l'activer. Après avoir installé Flash Attention, vous pouvez alors utiliser --cache-type-v q4_1

Si vous utilisez nos quantifications FP8 dynamiques Qwen3-Coder-Nextalors l'utilisation de la quantification FP8 du cache KV peut approximativement doubler le support de la longueur du contexte. Ajoutez --kv-cache-dtype fp8

📐Benchmarks

Qwen3-Coder-Next est le modèle offrant les meilleures performances 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 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