🌠Qwen3-Coder-Next：ローカルでの実行方法

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

Qwenは80B MoEモデル（アクティブパラメータ3B）のQwen3-Coder-Nextをリリースしました、これにより 256Kコンテキスト 高速なエージェント型コーディングとローカルでの使用が可能になります。アクティブパラメータが10〜20倍多いモデルと同等の性能です。

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

2月4日更新： llama.cpp の計算を修正するバグを修正しました、 ベクトル化された key_gdiff。 これにより以前のループや出力の問題が修正されます。GGUFを更新しましたので、どうぞ 再ダウンロード および更新 llama.cpp より良い出力のために。

また、CodexおよびClaude Codeでモデルを実行する方法も学べます。ファインチューニングの場合、 微調整（ファインチューニング）の場合、Qwen3-Next-CoderはUnslothでbf16 LoRAを行うために単一のB200 GPUに収まります。

Qwen3-Coder-Next Unsloth ダイナミックGGUF 実行するには： unsloth/Qwen3-Coder-Next-GGUF

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

⚙️ 使用ガイド

46GBのRAMや統一メモリがない？心配いりません。3ビットなどの小さい量子化モデルを実行できます。モデルサイズは計算資源の合計と等しいのが最良です（ ディスク容量 + RAM + VRAM ≥ 量子化サイズ）。 量子化モデルがデバイス上に完全に収まる場合、20トークン/秒以上を期待できます。収まらない場合でもオフロードで動作しますが遅くなります。

最適な性能を得るために、Qwenは以下の設定を推奨します：

Temperature = 1.0
Top_P = 0.95
Top_K = 40
Min_P = 0.01 （llama.cppのデフォルトは0.05）
リピートペナルティ = 無効または1.0

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

🖥️ Qwen3-Coder-Nextを実行する

ユースケースに応じて異なる設定が必要です。このガイドは4ビットを使用しているため、約46GBのRAM/統一メモリが必要です。最高のパフォーマンスには少なくとも3ビット精度を推奨します。

注意：このモデルは非思考モードのみをサポートしており、出力に <think></think> ブロックを生成しません。したがって指定することはできません enable_thinking=False もはや必要ありません。

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

llama.cppでの実行手順（ほとんどのデバイスに収めるために4ビットを使用します）：

最新の llama.cpp を GitHub で入手できます。下のビルド手順に従うこともできます。変更してください -DGGML_CUDA=ON から -DGGML_CUDA=OFF GPU がない場合や 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

Hugging Faceから直接取得できます。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

（以下をインストールした後に）モデルをダウンロードします pip install huggingface_hub）。量子化バージョンとして選べます UD-Q4_K_XL や他のもの。

pip install -U huggingface_hub
hf download unsloth/Qwen3-Coder-Next-GGUF \
    --local-dir unsloth/Qwen3-Coder-Next-GGUF \
    --include "*UD-Q4_K_XL*"

次にモデルを会話モードで実行します：

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

🦙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": "HTMLでFlappy Birdゲームを作成して"},],
)
print(completion.choices[0].message.content)

これが出力されます：

ここに単一ファイルに収められた完全に動作するFlappy Birdゲームがあります。

グラフィックスにはHTML5 Canvasを、物理（重力、衝突検出、スコアリング）にはJavaScriptを使用しました。外部画像やダウンロードは不要で、鳥とパイプはコードで描画されます。

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

```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; /* 空色 */
            border: 4px solid #000;
        }

        #ui-layer {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none; /* クリックをキャンバスに通す */
            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>クリック</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;
                    break;
                        bird.jump();
                        break;
                    case 'PLAYING':
                        startGame();
                        bird.jump();
                        break;
                }
            }
        }

        break;
        case 'GAMEOVER':
        break;

        window.addEventListener('keydown', handleInput);
        canvas.addEventListener('mousedown', handleInput);

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

canvas.addEventListener('touchstart', handleInput);
// 初期化
loop();
### このバージョンの特徴：
1. **物理:** 現実的な重力とジャンプの動作。
2. **衝突検知:** パイプ、床、天井に当たるとゲームが終了します。
3. **スコアシステム:** 通過したパイプごとに1ポイント獲得します。

4. **ハイスコア:** ブラウザのLocalStorageを使用して、ページを更新しても最高スコアを記憶します。

5. レスポンシブな操作: Spaceバー、マウスクリック、タッチ（モバイル向け）で動作します。

6. **グラフィックス:** 鳥はコードで描かれており（目やくちばし含む）、パイプには枠線があるため画像リンク切れは発生しません。 HTMLを抽出して実行したところ、生成されたFlappy Birdの例は正常に動作しました！👾 OpenAI Codex & Claude CodeGLM-4.7-Flashモデルをローカルのエージェント型コーディングワークロードで実行するには、 llama-server ガイドに従ってください、

Claude Code & OpenAI Codex

モデル名 '

' を 'Qwen3-Coder-Next' に変更し、Qwen3-Coder-Nextの正しいパラメータと使用手順に従ってください。先ほど設定した を使用します。 :

もし次のように表示されたら Claude Codeの指示に従った例では、次のようになります： 次に例えば以下のように要求できます、 📐長いコンテキストに適合させる方法

チェスのPythonゲームを作成して

APIエラー: 400 {"error":{"code":400,"message":"リクエスト（16582トークン）が利用可能なコンテキストサイズ（16384トークン）を超えています。増加を試みてください","type":"exceed_context_size_error","n_prompt_tokens":16582,"n_ctx":16384}} これはコンテキスト長を増やす必要があるか、を参照する必要があることを意味します 🎱 vLLMのFP8 Qwen3-Coder-Next 新しい FP8 ダイナミック量子化 nvidia-smi をプレミアムかつ高速な推論のためにモデルに使用できます。まずnightlyからvLLMをインストールします。を変更してください、 --extra-index-url https://wheels.vllm.ai/nightly/cu130 および お使いのCUDAバージョンは次で確認できます、 - のみ

cu129
cu130

が現在サポートされています。
# より速い環境インストールのために uv がなければインストールしてください
curl -LsSf https://astral.sh/uv/install.sh | sh

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

# 新しいPython環境を作成します - システム全体を変更したくない場合は不要です uv venv unsloth_fp8 --python 3.12 --seed source unsloth_fp8/bin/activate --kv-cache-dtype fp8 次にサーブします、 UnslothのダイナミックFP8バージョン そして、次を設定します のモデルを。FP8を有効にするとKVキャッシュのメモリ使用量を約50%削減できます。を追加してください 私たちは4 GPUでサーブしましたが、1 GPUしかない場合は、次を使用してください、 tmux CUDA_VISIBLE_DEVICES='0' --tensor-parallel-size 1 またはこの引数を削除してください。下記を新しいターミナルで起動してからCTRL+B+Dを使い、戻るには

export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
tmux attach-session -t0
    を使用します。
    CUDA_VISIBLE_DEVICES='0,1,2,3' vllm serve unsloth/Qwen3-Coder-Next-FP8-Dynamic \
    --served-model-name unsloth/Qwen3-Coder-Next \
    --enable-auto-tool-choice \
    --dtype bfloat16 \
    --seed 3407 \
    --max-model-len 200000 \
    --gpu-memory-utilization 0.93 \
    --port 8001

--tensor-parallel-size 4 \ Qwen3-Coder-Next --tool-call-parser qwen3_coder \

🔧以下のような表示が出るはずです。使い方については、を参照してください、

新しいターミナルで、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 substract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "遠い昔、はるか彼方の銀河で...",
        "ナマケモノとコードを愛する二人の友人がいました...",
        "世界はすべてのナマケモノが超人的知能を獲得したため終わりを迎えていた...",
        "一方の友人が知らないうちに、もう一方がナマケモノを進化させるプログラムを誤って作成してしまった...",
    ])
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"ターミナルコマンド `{command}` を実行しています")
    _ = create_locked_down_function(function)
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"コマンドが失敗しました: {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": "二つの数を加えます。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "二番目の数。",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "二つの数を掛けます。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "二番目の数。",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "substract_number",
            "description": "二つの数を引きます。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "二番目の数。",
                    },
                },
                "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"使用中のモデル = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"現在の 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),})
        scores.append(2.0)   # 動作したが2048には到達しなかった
            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": "Write 'I'm a happy Sloth' to a file, then print it back to me."}],
}]
messages = unsloth_inference(messages, temperature = 1.0, top_p = 1.0, top_k = 40, min_p = 0.00)

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

詳細については Tool Calling Guide vLLMやllama-serverでのOpenAI APIとツールコールを使ったQwen3-Coder-Nextの実際の使用方法。

🛠️ 生成速度の向上

Qwen3-Coder-Nextでのツールコール Qwen3-Coder-Next

もしVRAMがより多くある場合は、さらに多くのMoE層をオフロードするか、層全体をオフロードすることを試すことができます。

通常、 -ot ".ffn_.*_exps.=CPU" はすべてのMoE層をCPUにオフロードします！これにより非MoE層を1つのGPUに収めることができ、生成速度が向上します。GPU容量が大きい場合は正規表現をカスタマイズしてより多くの層を適合させることができます。

もしもう少しGPUメモリがあるなら、次を試してください -ot ".ffn_(up|down)_exps.=CPU" これはupおよびdownの投影MoE層をオフロードします。

試してみてください -ot ".ffn_(up)_exps.=CPU" もしさらに多くのGPUメモリがある場合。これはup投影MoE層のみをオフロードします。

正規表現をカスタマイズすることもできます。例えば -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" は6層目以降のgate、up、downのMoE層をオフロードすることを意味します。

その最新のllama.cppリリースは高スループットモードも導入します。使用すると、 llama-parallelです。詳細はここを参照してください。さらに、 KVキャッシュを4ビットに量子化することもできます 例えばVRAM / RAMの移動を減らし、生成プロセスをより高速にすることができます。次のセクションはKVキャッシュの量子化について説明します。

📐長いコンテキストに適合させる方法

より長いコンテキストを収めるには、 KVキャッシュの量子化 を使用してKおよびVキャッシュをより低いビットに量子化できます。これによりRAM/VRAMのデータ移動が減り、生成速度が向上することがあります。K量子化の許容オプション（デフォルトは f16）には以下が含まれます。

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

若干精度が向上するために _1 変種を使用するべきですが、わずかに遅くなります。例えば q4_1, q5_1 それで、次を試してください --cache-type-k q4_1

Vキャッシュも量子化できますが、その場合は llama.cppをFlash Attentionサポートでコンパイルする必要があります には次を使用してください -DGGML_CUDA_FA_ALL_QUANTS=ON、そして次を使用して --flash-attn で有効にします。Flash Attentionをインストールした後、次に --cache-type-v q4_1

ツールコールのより多くの例については、を参照してください。 Qwen3-Coder-NextvLLM / SGLangを使用している場合は、スループットを25%以上向上させることがあるFP8-Dynamic量子化を試してください！参照： --kv-cache-dtype fp8

📐ベンチマーク

ダイナミックFP8量子化を使用している場合、

ベンチマーク

FP8のKVキャッシュ量子化を使用するとコンテキスト長のサポートがほぼ2倍になることがあります。を追加してください

Qwen3-Coder-Nextはそのサイズにおいて最も高性能なモデルであり、性能はアクティブパラメータが10〜20倍多いモデルと同等です。

Qwen3-Coder-Next（80B）

DeepSeek-V3.2（671B）

GLM-4.7（358B）

70.6

70.2

74.2

74.8

MiniMax M2.1（229B）

62.8

62.3

63.7

66.2

SWE-Bench 検証済み（SWE-Agentあり）

44.3

40.9

40.6

34.6

SWE-Bench 多言語（SWE-Agentあり）

36.2

39.3

37.1

32.6

SWE-Bench Pro（SWE-Agentあり）、ターミナル-Bench 2.0（Terminus-2 jsonあり）、Aider

66.2

69.9

52.1

61.0

前へGLM-5 次へMiniMax-2.5

最終更新 1 日前

役に立ちましたか？

hashtag⚙️ 使用ガイド

hashtag🖥️ Qwen3-Coder-Nextを実行する

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

hashtag🦙Llama-serverのサービング＆デプロイメント

hashtag5. **レスポンシブな操作:** **Spaceバー**、**マウスクリック**、**タッチ**（モバイル向け）で動作します。

hashtagチェスのPythonゲームを作成して

hashtag🔧以下のような表示が出るはずです。使い方については、を参照してください、

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

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

hashtag🛠️ 生成速度の向上

hashtag📐長いコンテキストに適合させる方法

hashtag📐ベンチマーク

⚙️ 使用ガイド

🖥️ Qwen3-Coder-Nextを実行する

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

🦙Llama-serverのサービング＆デプロイメント

5. レスポンシブな操作: Spaceバー、マウスクリック、タッチ（モバイル向け）で動作します。

チェスのPythonゲームを作成して

🔧以下のような表示が出るはずです。使い方については、を参照してください、

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

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

🛠️ 生成速度の向上

📐長いコンテキストに適合させる方法

📐ベンチマーク