🌠Qwen3-Coder-Next: ローカル実行方法

Qwen3-Coder-Nextをデバイス上でローカル実行するためのガイド！

Qwen が Qwen3-Coder-Next をリリースしました。80B の MoE モデル（有効パラメータ 3B）で、 256Kのコンテキスト 高速なエージェント的コーディングとローカル利用向けです。10〜20倍多い有効パラメータを持つモデルに匹敵する性能です。

これは 46GB の RAM/VRAM/統合メモリ（8-bit では 85GB）で動作し、超高速なコード応答のために非推論モードです。このモデルは長期的な推論、複雑なツール使用、実行失敗からの復旧に優れています。

2月19日更新: llama.cpp の解析修正後、ツール呼び出しはさらに良くなっているはずです。

新機能！ 参照 量子化ベンチマーク を Dynamic GGUF 用に！

2月4日: llama.cpp の計算を修正するバグを直しました vectorized key_gdiff。 これにより、以前のループと出力の問題が修正されます。GGUF を更新したので、 再ダウンロード および 更新 llama.cpp して、より良い出力をお試しください。

また、Codex と Claude Code でモデルを実行する方法も学べます。 ファインチューニングについては、Qwen3-Next-Coder は Unsloth で bf16 LoRA を使う場合、1枚の B200 GPU に収まります。

Qwen3-Coder-Next Unsloth Dynamic GGUF を実行するには: unsloth/Qwen3-Coder-Next-GGUF

GGUF 実行チュートリアルCodex & Claude CodeFP8 vLLM チュートリアル

⚙️ 使用ガイド

46GB の RAM か統合メモリがありませんか？心配いりません。3-bit のような小さい量子化版を実行できます。モデルサイズは計算資源の合計（ ディスク容量 + RAM + VRAM ≥ 量子化版のサイズ）と同じかそれ以上であるのが理想です。 量子化版がデバイスに完全に収まるなら、20 tokens/s 超が期待できます。収まらなくてもオフロードで動作しますが、速度は遅くなります。

を使用します。最適な性能を得るために、Qwenは以下の設定を推奨しています:

• Temperature = 1.0

• Top_P = 0.95

• Top_K = 40

• Min_P = 0.01 （llama.cpp のデフォルトは 0.05）

• 繰り返しペナルティ = 無効 または 1.0

最大 262,144 のコンテキストをネイティブにサポートしますが、 32,768 メモリ使用量を抑えるための token。

🖥️ Qwen3-Coder-Next を実行

用途に応じて、異なる設定を使う必要があります。このガイドでは 4-bit を使用するため、約 46GB の RAM/統合メモリが必要です。最良の性能のため、少なくとも 3-bit 精度の使用を推奨します。

🦥 Unsloth Studio ガイド

Qwen3-Coder-Next は次の環境で実行・ファインチューニングできます Unsloth Studioで実行およびファインチューニングできます。これはローカル AI 向けの新しいオープンソース Web UI です。Unsloth Studio を使えば、モデルをローカルで実行できます MacOS、Windows、Linux および:

• 検索、ダウンロード、 GGUF を実行 し、safetensor モデルを扱う

• 自己修復 ツール呼び出し + Web 検索

• コード実行 （Python、Bash）

• 自動推論 パラメータ調整（temp、top-p など）

• llama.cpp を介した高速な CPU + GPU 推論

• LLM を学習する VRAM を 70% 少なくして 2 倍高速

1

Unslothをインストールする

ターミナルで実行:

MacOS、Linux、WSL:

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

Windows PowerShell:

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

インストールはすぐに終わり、およそ1〜2分かかります。

2

Unsloth を起動

MacOS、Linux、WSL、Windows：

unsloth studio -H 0.0.0.0 -p 8888

その後、 http://localhost:8888 をブラウザで開いてください。

3

Qwen3-Coder-Next を検索してダウンロード

初回起動時には、アカウントを保護するためのパスワードを作成し、後で再度サインインする必要があります。その後、モデル、データセット、基本設定を選ぶ簡単な初期設定ウィザードが表示されます。いつでもスキップして、直接チャットへ進めます。

その後、 Studio Chat タブで Qwen3-Coder-Next を検索バーに入力し、希望するモデルと量子化版をダウンロードしてください。

4

Qwen3-Coder-Next を実行

Unsloth Studio を使用すると推論パラメータは自動設定されるはずですが、手動で変更することもできます。コンテキスト長、チャットテンプレート、その他の設定も編集できます。

詳細は、 Unsloth Studio 推論ガイド.

Llama.cpp チュートリアル（GGUF）：

llama.cpp で実行するための手順（ほとんどのデバイスに収まるよう 4-bit を使用します）:

1

最新の llama.cpp を GitHub こちらから取得してください。以下のビルド手順に従うこともできます。 -DGGML_CUDA=ON を -DGGML_CUDA=OFF に変更してください。GPU がない場合、または CPU 推論だけを使いたい場合です。 Apple Mac / Metal デバイスの場合、次を設定して -DGGML_CUDA=OFF その後は通常どおり続けてください - Metal サポートは既定で有効です。

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

Hugging Face から直接 pull できます。RAM/VRAM に収まるなら、コンテキストを 256K まで増やせます。 --fit on を使うと、コンテキスト長も自動で判定されます。

推奨パラメータを使用できます: 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

モデルのダウンロード（ pip install huggingface_hubのインストール後）。 UD-Q4_K_XL などの他の量子化版もあります。ダウンロードが止まる場合は、 Hugging Face Hub、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

その後、会話モードでモデルを実行します:

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

また、 コンテキストウィンドウ 必要に応じて、最大で 262,144

注意: このモデルは非思考モードのみをサポートし、 <think></think> ブロックを出力しません。そのため、 enable_thinking=False を指定する必要はなくなりました。

🦙Llama-server のサービングとデプロイ

Qwen3-Coder-Next を本番環境にデプロイするには、 llama-server tmux などで新しいターミナルを開いてから、次の方法でモデルをデプロイします:

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

次に新しいターミナルで、 pip install openaiで、モデルを実行できます:

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)

すると次のように出力されます:

こちらは、1つのファイルに収められた完全に動作する Flappy Bird ゲームです。

グラフィックには **HTML5 Canvas**、物理演算（重力、衝突判定、スコアリング）には **JavaScript** を使用しています。外部画像やダウンロードは不要で、コードだけで鳥とパイプを描画します。

### 実行方法:
1.  以下のコードブロックをコピーします。
2.  `game.html` という名前でコンピュータ上に新しいファイルを作成します。
3.  そのファイルにコードを貼り付けて保存します。
4.  `game.html` をダブルクリックして Web ブラウザで開きます。

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>シンプルな 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; /* 空色 */
            border: 4px solid #000;
        }

        #ui-layer {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none; /* クリックを canvas に通過させる */
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            text-align: center;
        }

        .message {
            background: rgba(255, 255, 255, 0.8);
            padding: 20px;
            border-radius: 10px;
            color: #333;
        }

        #score-board {
            position: absolute;
            top: 20px;
            width: 100%;
            text-align: center;
            font-size: 40px;
            font-weight: bold;
            color: white;
            text-shadow: 2px 2px 0 #000;
            z-index: 10;
        }
    </style>
</head>
<body>

    <h1>Flappy Bird クローン</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>飛ぶ準備はできましたか？</h2>
                <p><strong>Space</strong> か <strong>Click</strong> でジャンプ</p>
                <p>Space を押して開始</p>
            </div>
            <div id="game-over-screen" class="message" style="display: none;">
                <h2>ゲームオーバー</h2>
                <p>スコア: <span id="final-score">0</span></p>
                <p>ベスト: <span id="best-score">0</span></p>
                <p>再開するには <strong>Space</strong> を押してください</p>
            </div>
        </div>
    </div>

    <script>
        // --- 設定 ---
        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');

        // ゲーム変数
        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; // パイプが左に移動する速度

        // --- 鳥オブジェクト ---
        const bird = {
            x: 50,
            y: 150,
            width: 30,
            height: 30,
            velocity: 0,
            jumpStrength: 4.5,
            radius: 15,
            draw: function() {
                ctx.fillStyle = "#FFD700"; // 金色
                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();

                // 目
                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();
                
                // くちばし
                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;

                // 床との衝突
                if (this.y + this.height >= canvas.height) {
                    this.y = canvas.height - this.height;
                    gameOver();
                }
                
                // 天井との衝突（任意: パイプを飛び越えないようにする）
                if (this.y < 0) {
                    this.y = 0;
                    this.velocity = 0;
                }
            },
            jump: function() {
                this.velocity = -this.jumpStrength;
            },
            reset: function() {
                this.y = 150;
                this.velocity = 0;
            }
        };

        // --- パイプ配列 ---
        const pipes = {
            position: [],
            width: 50,
            gap: 120, // 上下のパイプ間のスペース
            dx: 2, // 移動速度

            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"; // フォレストグリーン

                    // 上のパイプ
                    ctx.fillRect(p.x, 0, this.width, topY);
                    ctx.strokeRect(p.x, 0, this.width, topY);

                    // 下のパイプ
                    ctx.fillRect(p.x, bottomY, this.width, canvas.height - bottomY);
                    ctx.strokeRect(p.x, bottomY, this.width, canvas.height - bottomY);
                }
            },

            update: function() {
                // 120フレームごとに新しいパイプを追加（約2秒）
                if (frames % 120 === 0) {
                    // 上のパイプのランダムな高さ
                    // 最小高さ 50、最大高さ 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;

                    // 衝突判定
                    // ロジック: 鳥の X がパイプの X 範囲内にあるか確認
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // ロジック: 鳥の Y が上のパイプまたは下のパイプに当たっているか確認
                        if (bird.y < p.y || bird.y + bird.height > p.y + this.gap) {
                            gameOver();
                        }
                    }

                    // スコア更新（鳥がパイプを通過したとき）
                    if (p.x + this.width < bird.x && !p.passed) {
                        score++;
                        scoreElement.innerText = score;
                        p.passed = true;
                    }

                    // 画面外に出たパイプを削除
                    if (p.x + this.width <= 0) {
                        this.position.shift();
                        // 配列の長さが変わるので i を減らす
                        i--; 
                    }
                }
            },
            
            reset: function() {
                this.position = [];
            }
        };

        // --- 背景（雲/芝生）---
        const background = {
            draw: function() {
                // 芝生を描画
                ctx.fillStyle = "#7cfc00"; // 芝生グリーン
                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();
            }
        };

        // --- ゲーム制御関数 ---

        function loop() {
            // キャンバスをクリア
            ctx.clearRect(0, 0, canvas.width, canvas.height);

            // 背景を描画
            background.draw();

            if (gameState === 'START') {
                bird.draw();
                // 地面の線を描画
                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();
                // フレームや位置を更新せず、そのまま停止
            }

            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';
            
            // ハイスコアを更新
            if (score > highScore) {
                highScore = score;
                localStorage.setItem('flappyHighScore', highScore);
            }

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

        // --- 入力処理 ---

        function handleInput(e) {
            // 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);

        // 初期化
        loop();

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

### このバージョンの機能:
1.  **物理演算:** 現実的な重力とジャンプの仕組み。
2.  **衝突判定:** パイプ、床、天井に当たるとゲーム終了。
3.  **スコアシステム:** 通過したパイプごとに 1 点獲得。
4.  **ハイスコア:** ブラウザの LocalStorage を使って、ページを更新してもベストスコアを記憶。
5.  **レスポンシブ操作:** **Spacebar**、**Mouse Click**、または **Touch**（モバイル端末用）で動作。
6.  **グラフィック:** 鳥はコードで描画され（目とくちばしを含む）、パイプには枠線があるため、壊れた画像リンクは発生しません。

HTML を抽出して実行してみたところ、生成された Flappy Bird のサンプルはうまく動作しました！

👾 OpenAI Codex & Claude Code

ローカルのコーディングエージェント的ワークロード経由でモデルを実行するには、 ガイドに従ってください. モデル名 'GLM-4.7-Flash' を 'Qwen3-Coder-Next' に変更し、正しい Qwen3-Coder-Next のパラメータと使用手順に従ってください。 llama-server さっき設定した

Claude Code

OpenAI Codex

たとえばClaude Codeの手順に従うと、次が表示されます:

では、次のように依頼できます Pythonでチェスゲームを作成して :

次のような表示が出たら 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}} それは、コンテキスト長を増やす必要があるか、または Qwen3-Coder-Next

🎱 vLLM における FP8 Qwen3-Coder-Next

新しい FP8 Dynamic 量子化版 を使って、高品質で高速な推論が可能になりました。まず nightly 版から vLLM をインストールします。 --extra-index-url https://wheels.vllm.ai/nightly/cu130 を、次で確認したあなたの CUDA バージョンに変更してください nvidia-smi - 現在サポートされているのは cu129 および cu130 のみです。

vLLM / SGLang を使う場合は、スループットを 25% 以上向上できる FP8-Dynamic 量子化版を試してみてください！ Qwen3-Coder-Next

# より高速に環境を構築するため、uv がない場合はインストールしてください
curl -LsSf https://astral.sh/uv/install.sh | sh

# 新しい Python 環境を作成します - システム全体を変更したい場合は不要です
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

その後、 Unsloth の動的 FP8 版 のモデルをサーブします。さらに、次を追加することで KV キャッシュのメモリ使用量を 50% 削減するために FP8 を有効化することもできます --kv-cache-dtype fp8 4 GPU でサーブしましたが、1 GPU の場合は CUDA_VISIBLE_DEVICES='0' を使い、 --tensor-parallel-size 1 を設定するか、この引数を削除してください。 tmux を使って、下の処理を新しいターミナルで起動し、その後 CTRL+B+D - 次を使います tmux attach-session -t0 で戻れます。

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

以下のようなものが見えるはずです。 Qwen3-Coder-Next Qwen3-Coder-Next を OpenAI API とツール呼び出しで実際に使う方法については

🔧Qwen3-Coder-Next のツール呼び出し

新しいターミナルで、2つの数値の加算、Pythonコードの実行、Linux関数の実行など、さまざまなツールを作成します：

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([
        "はるか昔、はるか遠くの銀河で...",
        "スロースとコードを愛する2人の友人がいました...",
        "すべてのスロースが超人的な知能を持つよう進化したため、世界は終わろうとしていた...",
        "ある友人が気づかないうちに、もう一人が誤ってスロースを進化させるプログラムをコードしていた...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "'rm, sudo, dd, chmod' コマンドは危険なので実行できません"
        print(msg); return msg
    print(f"Executing terminal command `{command}`")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Command failed: {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": "2つの数を足します。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "2番目の数。",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "2つの数を掛けます。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "2番目の数。",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "subtract_number",
            "description": "2つの数を引きます。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "2番目の数。",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "ランダムな物語を書きます。",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "ターミナルから操作を実行します。",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "起動したいコマンド。例: `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "実行される Python コードを使って Python インタープリタを呼び出します。",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "実行する Python コード",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

その後、以下の関数（コピーして貼り付けて実行）を使用します。これにより関数呼び出しが自動的に解析され、任意のモデルに対して OpenAI エンドポイントが呼び出されます：

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

これから、さまざまなユースケースにおけるツール呼び出しの複数の方法を以下で紹介します：

生成されたPythonコードを実行する

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Python でフィボナッチ関数を作成し、fib(20) を求めてください。"}],
}]
unsloth_inference(messages, temperature = 1.0, top_p = 0.95, top_k = 40, min_p = 0.00)

任意のターミナル関数を実行する

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "'私は幸せなナマケモノです' をファイルに書き込み、それを私に表示してください。"}],
}]
messages = unsloth_inference(messages, temperature = 1.0, top_p = 1.0, top_k = 40, min_p = 0.00)

ファイルが作成されたことを確認し、実際に作成されています！

参照 Tool Calling Guide を参照してください。

📐ベンチマーク

GGUF 量子化ベンチマーク

以下は第三者評価者によって実施された量子化ベンチマークです。

Aider Polyglot ベンチマーク

Benjamine Marie ベンチマーク（ソース)

ベンチマークは第三者の寄稿者によって Aider Polyglot サーバー上で実施され、Aider Polyglot ベンチマーク（スコア対 VRAM）で Unsloth GGUF 量子化版を比較したものです。特に 3-bit UD-IQ3_XXS 量子化版は BF16 の性能にかなり近く、 3-bit は実用上の妥当な最小値 になっています。

NVFP4 は BF16 の参照値をわずかに上回っており、これは実行回数が少ないことによるサンプリングノイズかもしれません。しかし、全体的な傾向として 1-bit → 2-bit → 3-bit → 6-bit と着実に改善していることから、このベンチマークは Unsloth GGUF 間の意味のある品質差を捉えていると考えられます。 非 Unsloth の FP8 は、 UD-IQ3_XXS および UD-Q6_K_XLの両方より性能が低いようで、これは量子化パイプラインの違い、あるいは単にサンプリング不足を反映している可能性があります。

Benjamin Marie（第三者）がベンチマークを実施 Qwen3-Coder-Next Unsloth と Qwen GGUF を使って 750プロンプトの混合セット （LiveCodeBench v6、MMLU Pro、GPQA、Math500）で、次の両方を報告: 全体精度 および 相対誤差増加 （量子化モデルが元のモデルよりどれだけ多くミスするか）。

グラフは明確に、Unsloth の Q4_K_M 量子化版が標準の Q4_K_M より優れていることを示しています。Q3_K_M は Live Code Bench v6 では予想通り性能が劣りますが、HumanEval では標準の Q4_K_M より驚くほど良い結果です。 最も効率よく動作しているようなので、少なくとも Q4_K_M の使用を推奨します。

Qwen3-Coder-Next ベンチマーク

Qwen3-Coder-Next はサイズの割に最も高性能なモデルであり、その性能は 10〜20倍多い有効パラメータを持つモデルに匹敵します。

ベンチマーク	Qwen3-Coder-Next (80B)	DeepSeek-V3.2 (671B)	GLM-4.7 (358B)	MiniMax M2.1 (229B)
SWE-Bench Verified (w/ SWE-Agent)	70.6	70.2	74.2	74.8
SWE-Bench Multilingual (w/ SWE-Agent)	62.8	62.3	63.7	66.2
SWE-Bench Pro (w/ SWE-Agent)	44.3	40.9	40.6	34.6
Terminal-Bench 2.0 (w/ Terminus-2 json)	36.2	39.3	37.1	32.6
Aider	66.2	69.9	52.1	61.0