# Kimi K2.5: ローカル実行ガイド

Kimi-K2.5 は Moonshot の新しいモデルで、視覚、コーディング、エージェント、チャットの各タスクで SOTA 性能を達成します。1T パラメータのハイブリッド推論モデルは 600GB のディスク容量を必要としますが、量子化版は **Unsloth Dynamic 1.8-bit** これを 240GB（-60% のサイズ）に削減します**:** [**Kimi-K2.5-GGUF**](https://huggingface.co/unsloth/Kimi-K2.5-GGUF)

すべてのアップロードは Unsloth [Dynamic 2.0](/docs/jp/ji-ben/unsloth-dynamic-2.0-ggufs.md) SOTA の Aider および 5-shot MMLU の性能向け。Dynamic 1–2 bit GGUF が以下でどのような性能を示すかご覧ください [コーディングベンチマーク](/docs/jp/ji-ben/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md).

### :gear: 推奨要件

{% hint style="info" %}
必要なのは >**240GB のディスク容量** 1-bit 量子化を実行するためです！

最適な性能を得るには、利用可能な総メモリ（VRAM + システム RAM）が、ダウンロードする量子化済みモデルファイルのサイズを上回っていることを確認してください。そうでない場合でも、llama.cpp は SSD/HDD オフローディング経由で実行できますが、推論は遅くなります。
{% endhint %}

1.8-bit（UD-TQ1\_0）量子化は、すべての MoE 層をシステム RAM（または高速 SSD）にオフロードすれば、単一の 24GB GPU で動作します。RAM が約 256GB あれば、約 10 トークン/秒が見込めます。Kimi K2.5 のフルモデルは 630GB で、通常は少なくとも 4× H200 GPU が必要です。

モデルが収まれば、B200 を使うと >40 トークン/秒が得られます。

モデルをほぼ **フル精度**で動かすには、4-bit か 5-bit の量子化を使えます。安全を見て、より高い量子化を使っても構いません。

高い性能を得るには、10+ トークン/秒に到達するために >240GB の共有メモリ（または RAM+VRAM の合計）を目指してください。それ未満でも動作はしますが、速度は低下します（llama.cpp は mmap/ディスクオフロード経由でも実行可能です）。約 10 トークン/秒から <2 トークン/秒まで落ちることがあります。

サイズと品質のバランスが良いものとして UD-Q2\_K\_XL（375GB）を推奨します。目安は、RAM+VRAM ≈ 量子化サイズ です。それ以外でも動作しますが、オフロードのために遅くなります。

## 🥝 Kimi K2.5 実行ガイド

Kimi-K2.5 は、用途ごとに異なるサンプリングパラメータが必要です。

現在は **視覚サポートがありません** が、llama.cpp がまもなく対応してくれることを期待しています。

{% hint style="success" %}
**モデルを完全精度で実行するには、4-bit または 5-bit の Dynamic GGUF（例: UD\_Q4\_K\_XL）を使うだけで十分です。元々モデルが INT4 形式で公開されているためです。**

小さな量子化差異に備えて念のためより高ビットの量子化を選ぶこともできますが、ほとんどの場合は不要です。
{% endhint %}

### 🌙 使用ガイド:

Moonshot AI によると、Kimi K2.5 の推論に推奨される設定は次のとおりです:

| デフォルト設定（Instant モード）                                               | Thinking モード                                                       |
| ------------------------------------------------------------------ | ------------------------------------------------------------------ |
| <mark style="background-color:green;">**temperature = 0.6**</mark> | <mark style="background-color:green;">**temperature = 1.0**</mark> |
| <mark style="background-color:green;">**top\_p = 0.95**</mark>     | <mark style="background-color:green;">**top\_p = 0.95**</mark>     |
| min\_p = 0.01                                                      | min\_p = 0.01                                                      |

* 次を設定してください **temperature 1.0** 重複や不整合を減らすため。
* 推奨コンテキスト長 = 98,304（最大 256K）
* 注: 使用するツールによって設定が異なる場合があります

{% hint style="info" %}
次の設定を推奨します <mark style="background-color:green;">**min\_p を 0.01 に**</mark> 低確率のありえないトークンの出現を抑制するため。さらに **repeat penalty を無効化するか、1.0 に設定** してください。
{% endhint %}

#### Kimi K2.5 のチャットテンプレート

実行すると `tokenizer.apply_chat_template([{"role": "user", "content": "1+1 は何ですか?"},])` 次のようになります:

{% code overflow="wrap" %}

```
<|im_system|>system<|im_middle|>あなたは Moonshot AI によって作成された AI アシスタント、Kimi です。<|im_end|><|im_user|>user<|im_middle|>1+1 は何ですか?<|im_end|><|im_assistant|>assistant<|im_middle|><think>
```

{% endcode %}

#### 🦥 Unsloth Studio で Kimi-K2.5 を実行

Kimi-K2.5 は [Unsloth Studio](/docs/jp/xin-zhe/studio.md)で実行およびファインチューニングできます。これはローカル AI 向けの新しいオープンソース Web UI です。Unsloth Studio を使えば、モデルをローカルで実行できます **MacOS、Windows**、Linux および:

{% columns %}
{% column %}

* 検索、ダウンロード、 [GGUF を実行](/docs/jp/xin-zhe/studio.md#run-models-locally) し、safetensor モデルを扱う
* [**自己修復** ツール呼び出し](/docs/jp/xin-zhe/studio.md#execute-code--heal-tool-calling) + **Web 検索**
* [**コード実行**](/docs/jp/xin-zhe/studio.md#run-models-locally) （Python、Bash）
* [自動推論](/docs/jp/xin-zhe/studio.md#model-arena) パラメータ調整（temp、top-p など）
* llama.cpp を介した高速な CPU + GPU 推論
* [LLM を学習する](/docs/jp/xin-zhe/studio.md#no-code-training) VRAM を 70% 少なくして 2 倍高速
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/c32867f999db074387ac16732ce548485cc593de" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}
**Unslothをインストールする**

ターミナルで実行:

MacOS、Linux、WSL:

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

Windows PowerShell:

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

{% hint style="success" %}
**インストールはすぐに終わり、およそ1〜2分かかります。**
{% endhint %}
{% endstep %}

{% step %}
**Unsloth を起動**

MacOS、Linux、WSL、Windows：

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

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

{% step %}
**Kimi-K2.5 を検索してダウンロード**

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

その後、 [Studio Chat](/docs/jp/xin-zhe/studio/chat.md) タブで **Kimi-K2.5** を検索バーで検索し、必要なモデルと量子化版をダウンロードしてください。モデルを実行するのに十分な計算資源があることを確認してください。

<div data-with-frame="true"><figure><img src="/files/f3aa88ffb684b47b231b5f7f3b11f9664791ff96" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}
**Kimi-K2.5 を実行**

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

詳細は、 [Unsloth Studio 推論ガイド](/docs/jp/xin-zhe/studio/chat.md).

<div data-with-frame="true"><figure><img src="/files/44d9105dd956eac31f9586bcf01055a289b0ef3e" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

### ✨ llama.cpp で Kimi K2.5 を実行

このガイドでは、最小の 1-bit 量子化版（サイズ 240GB）を実行します。量子化タイプは 2-bit、3-bit などに自由に変更できます。モデルをほぼ **フル精度**で動かすには、4-bit か 5-bit の量子化を使えます。安全を見て、より高い量子化を使っても構いません。

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

```bash
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. もし `llama.cpp` モデルを直接読み込むには、以下のようにできます。(:UD-TQ1\_0) は量子化タイプです。Hugging Face（ポイント3）経由でもダウンロードできます。これは次と同様です: `ollama run` に似ています。使用 `export LLAMA_CACHE="folder"` して `llama.cpp` 特定の場所に保存するために。

{% hint style="success" %}
`LLAMA_SET_ROWS=1` は llama.cpp を少し速くします！使いましょう！ `--fit on` すべての GPU と CPU にモデルを最適に自動フィットさせます。
{% endhint %}

```bash
export LLAMA_CACHE="unsloth/Kimi-K2.5-GGUF"
LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \\
    -hf unsloth/Kimi-K2.5-GGUF:UD-TQ1_0\
    --temp 1.0 \
    --min-p 0.01 \\
    --top-p 0.95 \
    --ctx-size 16384 \\
    --seed 3407
```

3. `--fit on` を使えば、モデルはシステムに自動フィットします。 `--fit on` もし使用せず、GPU の合計メモリが約 360GB ある場合は、 `-ot ".ffn_.*_exps.=CPU"` を削除して最大速度を得てください。

{% hint style="info" %}
使用 `--fit on` GPU と CPU への自動フィット用です。うまくいかない場合は、下記を参照してください:

ぜひ試してみてください `-ot ".ffn_.*_exps.=CPU"` すべての MoE レイヤーを CPU にオフロードします！これにより、非 MoE レイヤーを 1 枚の GPU に収められるようになり、生成速度が向上します。GPU 容量がさらにある場合は、正規表現を調整してより多くのレイヤーを収めることができます。

GPU メモリがもう少し多い場合は、試してみてください `-ot ".ffn_(up|down)_exps.=CPU"` これにより、アップ投影とダウン投影の MoE レイヤーがオフロードされます。

試してみてください `-ot ".ffn_(up)_exps.=CPU"` GPU メモリがさらに多い場合は、これを使ってください。これにより、アップ投影の MoE レイヤーのみがオフロードされます。

そして最後に、 `-ot ".ffn_.*_exps.=CPU"` を使ってすべてのレイヤーをオフロードします。

これは最も少ない VRAM を使用します。 `正規表現をカスタマイズすることもできます。例えば` -ot "\\.(6|7|8|9|\[0-9]\[0-9]|\[0-9]\[0-9]\[0-9])\\.ffn\_(gate|up|down)\_exps.=CPU"
{% endhint %}

3. モデルのダウンロード（ `pip install huggingface_hub hf_transfer` 最大速度を得てください！ [huggingface.co/unsloth/Kimi-K2.5-GGUF](https://huggingface.co/unsloth/Kimi-K2.5-GGUF) ダウンロードが止まる場合は、 [Hugging Face Hub、XETデバッグ](/docs/jp/ji-ben/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

{% code overflow="wrap" %}

```bash
pip install -U huggingface_hub
hf download unsloth/Kimi-K2.5-GGUF \\
    --local-dir unsloth/Kimi-K2.5-GGUF \\
    --include "*UD-TQ1_0*" # Dynamic 2bit には "*UD-Q2_K_XL*" を使用
```

{% endcode %}

{% hint style="info" %}
ダウンロードが 90〜95% あたりで止まる場合は、 [トラブルシューティングガイド](https://docs.unsloth.ai/basics/troubleshooting-and-faqs#downloading-gets-stuck-at-90-to-95).
{% endhint %}

4. 任意のプロンプトを実行。
5. 編集  `--ctx-size 16384` をご覧ください。コンテキスト長のためです。 `--fit on`

{% code overflow="wrap" %}

```bash
LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \\
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \\
    --temp 1.0 \
    --min-p 0.01 \\
    --top-p 0.95 \
    --ctx-size 16384 \\
    --seed 3407
```

{% endcode %}

6. 例として、"HTML で Flappy Bird ゲームを作成して" と入力すると、次のようになります:

{% columns %}
{% column width="33.33333333333333%" %}

<figure><img src="/files/5fd902ec11d61fa200eabaea4df2cdde8fa59e75" alt="" width="188"><figcaption></figcaption></figure>
{% endcolumn %}

{% column width="66.66666666666667%" %}
{% code expandable="true" %}

```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;
            background: #222;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            font-family: 'Segoe UI', sans-serif;
            overflow: hidden;
            touch-action: none;
        }
        
        #game-container {
            position: relative;
            width: 400px;
            height: 600px;
            background: linear-gradient(to bottom, #70c5ce 0%, #70c5ce 80%, #c23810 80%, #c23810 100%);
            box-shadow: 0 0 20px rgba(0,0,0,0.5);
            overflow: hidden;
        }
        
        canvas {
            display: block;
        }
        
        .overlay {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            text-align: center;
            color: white;
            text-shadow: 2px 2px 0 #000;
            font-weight: bold;
            pointer-events: none;
        }
        
        .game-title {
            font-size: 48px;
            margin-bottom: 20px;
        }
        
        .score-display {
            font-size: 36px;
            margin-bottom: 10px;
        }
        
        .best-score {
            font-size: 24px;
            color: #ffe;
        }
        
        .instruction {
            font-size: 20px;
            animation: pulse 1s infinite;
        }
        
        @keyframes pulse {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; }
        }
        
        .hidden { display: none; }
    </style>
</head>
<body>
    <div id="game-container">
        <canvas id="canvas" width="400" height="600"></canvas>
        
        <!-- スタート画面 -->
        <div id="start-screen" class="overlay">
            <div class="game-title">FLAPPY BIRD</div>
            <div class="instruction">クリックまたはスペースで飛ぶ</div>
        </div>
        
        <!-- ゲームオーバー画面 -->
        <div id="game-over-screen" class="overlay hidden">
            <div class="game-title">GAME OVER</div>
            <div class="score-display">スコア: <span id="final-score">0</span></div>
            <div class="best-score">ベスト: <span id="best-score">0</span></div>
            <div class="instruction">クリックして再開</div>
        </div>
        
        <!-- スコアカウンター -->
        <div id="current-score" class="overlay hidden" style="top: 10%; font-size: 72px; color: white; text-shadow: 4px 4px 0 #000;">
            0
        </div>
    </div>

    <script>
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        
        // ゲーム定数
        const GRAVITY = 0.4;
        const JUMP_STRENGTH = -7;
        const PIPE_SPEED = 3;
        const PIPE_SPAWN_RATE = 120; // フレーム
        const PIPE_GAP = 120;
        
        // ゲーム状態
        let bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
        let pipes = [];
        let score = 0;
        let bestScore = localStorage.getItem('flappyBest') || 0;
        let frameCount = 0;
        let isGameOver = false;
        let isPlaying = false;
        
        // DOM 要素
        const startScreen = document.getElementById('start-screen');
        const gameOverScreen = document.getElementById('game-over-screen');
        const currentScoreDisplay = document.getElementById('current-score');
        const finalScoreEl = document.getElementById('final-score');
        const bestScoreEl = document.getElementById('best-score');
        
        // 入力処理
        function handleInput(e) {
            if (!isPlaying) {
                if (isGameOver) {
                    resetGame();
                }
                startGame();
            } else if (!isGameOver) {
                bird.velocity = JUMP_STRENGTH;
                bird.wingState = 1;
            }
        }
        
        document.addEventListener('keydown', (e) => {
            if (e.code === 'Space' || e.code === 'ArrowUp') handleInput(e);
        });
        canvas.addEventListener('pointerdown', handleInput);
        
        function startGame() {
            isPlaying = true;
            isGameOver = false;
            startScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function resetGameState() {
            bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
            pipes = [];
            score = 0;
            frameCount = 0;
            currentScoreDisplay.textContent = score;
        }
        
        function resetGame() {
            isGameOver = false;
            isPlaying = true;
            gameOverScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function spawnPipe() {
            const minHeight = 100;
            const maxHeight = 400;
            const topHeight = Math.floor(Math.random() * (maxHeight - minHeight + 1) + minHeight);
            const bottomHeight = canvas.height - topHeight - PIPE_GAP;
            
            pipes.push({
                x: canvas.width,
                topHeight: topHeight,
                bottomY: topHeight + PIPE_GAP,
                bottomHeight: bottomHeight,
                passed: false
            });
        }
        
        function update() {
            if (isGameOver) return;
            
            // 鳥の物理
            bird.velocity += GRAVITY;
            bird.y += bird.velocity;
            
            // 床/天井との衝突
            if (bird.y + bird.radius > canvas.height || bird.y - bird.radius < 0) {
                gameOver();
                return;
            }
            
            // パイプ生成
            frameCount++;
            if (frameCount % PIPE_SPAWN_RATE === 0) {
                spawnPipe();
            }
            
            // パイプの移動と衝突
            for (let i = pipes.length - 1; i >= 0; i--) {
                const pipe = pipes[i];
                pipe.x -= PIPE_SPEED;
                
                // 画面外のパイプを削除
                if (pipe.x + 60 < 0) {
                    pipes.splice(i, 1);
                    continue;
                }
                
                // 衝突判定（簡易的な矩形-円）
                const pipeWidth = 60;
                const pipeX = pipe.x;
                const pipeLeft = pipeX;
                const pipeRight = pipeX + pipeWidth;
                
                // 鳥は円、パイプは矩形
                const birdLeft = bird.x - bird.radius + 4; // +4 はくちばしのオフセット
                const birdRight = bird.x + bird.radius + 2;
                const birdTop = bird.y - bird.radius;
                const birdBottom = bird.y + bird.radius;
                
                // 水平方向の衝突チェック
                if (birdRight > pipeLeft && birdLeft < pipeRight) {
                    // 上パイプとの衝突
                    if (birdTop < pipe.topHeight) {
                        gameOver();
                        return;
                    }
                    // 下パイプとの衝突
                    if (birdBottom > pipe.bottomY) {
                        gameOver();
                        return;
                    }
                }
                
                // スコア計算
                if (pipe.x + pipeWidth < bird.x && !pipe.passued) {
                    pipe.passed = true;
                    score++;
                    currentScoreDisplay.textContent = score;
                }
            }
            
            // 羽をアニメーション
            if (bird.wingState > 0) {
                bird.wingState = (bird.wingState + 0.2) % 2;
            }
        }
        
        function draw() {
            // キャンバスをクリア
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // パイプを描画
            pipes.forEach(pipe => {
                // 上パイプ
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, 0, 60, pipe.topHeight);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.topHeight - 20, 60, 20); // キャップ
                
                // 下パイプ
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, pipe.bottomY, 60, canvas.height - pipe.bottomY);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.bottomY - 20, 60, 20); // キャップ
            });
            
            // 鳥を描画（くちばし付きの円）
            ctx.fillStyle = '#e3bc4e';
            ctx.beginPath();
            ctx.arc(bird.x, bird.y, bird.radius, 0, Math.PI * 2);
            ctx.fill();
            
            // くちばし
            ctx.fillStyle = '#e04c4c';
            ctx.beginPath();
            ctx.moveTo(bird.x + bird.radius - 4, bird.y - 4);
            ctx.lineTo(bird.x + bird.radius + 10, bird.y);
            ctx.lineTo(bird.x + bird.radius - 4, bird.y + 4);
            ctx.fill();
            
            // 目
            ctx.fillStyle = 'black';
            ctx.beginPath();
            ctx.arc(bird.x + 5, bird.y - 6, 3, 0, Math.PI * 2);
            ctx.fill();
            
            // 羽
            ctx.fillStyle = '#c4a';
            ctx.beginPath();
            ctx.ellipse(bird.x - 5, bird.y + 5, 10, 6, 0, 0, Math.PI * 2);
            ctx.fill();
        }
        
        function gameOver() {
            isGameOver = true;
            isPlaying = false;
            
            // ベストスコアを更新
            if (score > bestScore) {
                bestScore = score;
                localStorage.setItem('flappyBest', bestScore);
            }
            
            // ゲームオーバー画面を表示
            currentScoreDisplay.classList.add('hidden');
            gameOverScreen.classList.remove('hidden');
            finalScoreEl.textContent = score;
            bestScoreEl.textContent = bestScore;
        }
        
        function gameLoop() {
            if (!isPlaying) return;
            
            update();
            draw();
            requestAnimationFrame(gameLoop);
        }
        
        // 初期描画
        draw();
    </script>
</body>
</html>
```

{% endcode %}
{% endcolumn %}
{% endcolumns %}

### ✨ llama-server と OpenAI の completion ライブラリでデプロイ

{% hint style="success" %}
を使うと `--kv-unified` は llama.cpp での推論サービングを高速化できます！こちらを参照: <https://www.reddit.com/r/LocalLLaMA/comments/1qnwa33/glm_47_flash_huge_performance_improvement_with_kvu/>
{% endhint %}

に従って llama.cpp をインストールした後、以下を使って OpenAI 互換サーバーを起動できます: [#run-kimi-k2-thinking-in-llama.cpp](#run-kimi-k2-thinking-in-llama.cpp "mention")、以下を使って OpenAI 互換サーバーを起動できます:

{% code overflow="wrap" %}

```bash
LLAMA_SET_ROWS=1 ./llama.cpp/llama-server \\
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \\
    --special \\
    --alias "unsloth/Kimi-K2.5" \\
    --min-p 0.01 \\
    --ctx-size 16384 \\
    --port 8001 \\
    --kv-unified
```

{% endcode %}

その後、OpenAI の Python ライブラリを使います `pip install openai` :

```python
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/Kimi-K2.5",
    messages = [{"role": "user", "content": "1+1 は何ですか?"},],
)
print(completion.choices[0].message.content)
```

そして、次の結果になります:

<figure><img src="/files/94905f59efd41b2901201bd5c3ac7a576f5c680e" alt="" width="563"><figcaption></figcaption></figure>

そして、別の llama-server 画面では:

<figure><img src="/files/b59e997e3c127503e8b00c914a58b0176f583abb" alt="" width="563"><figcaption></figcaption></figure>

### 📊 ベンチマーク

以下で、ベンチマークを表形式で確認できます：

<figure><img src="/files/968b005e03c9db79f51c864a4ff1672d73fca737" alt="" width="375"><figcaption></figcaption></figure>

#### 推論 & 知識

| ベンチマーク          | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| --------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| HLE-フル          |      30.1 |    34.5 |            30.8 |         37.5 |         25.1† |                           - |
| HLE-フル（ツール使用）   |      50.2 |    45.5 |            43.2 |         45.8 |         40.8† |                           - |
| AIME 2025       |      96.1 |     100 |            92.8 |         95.0 |          93.1 |                           - |
| HMMT 2025（2月）   |      95.4 |    99.4 |          92.9\* |       97.3\* |          92.5 |                           - |
| IMO-AnswerBench |      81.8 |    86.3 |          78.5\* |       83.1\* |          78.3 |                           - |
| GPQA-Diamond    |      87.6 |    92.4 |            87.0 |         91.9 |          82.4 |                           - |
| MMLU-Pro        |      87.1 |  86.7\* |          89.3\* |         90.1 |          85.0 |                           - |

#### 画像 & 動画

| ベンチマーク           | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| ---------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| MMMU-Pro         |      78.5 |  79.5\* |            74.0 |         81.0 |             - |                        69.3 |
| CharXiv（RQ）      |      77.5 |    82.1 |          67.2\* |         81.4 |             - |                        66.1 |
| MathVision       |      84.2 |    83.0 |          77.1\* |       86.1\* |             - |                        74.6 |
| MathVista（mini）  |      90.1 |  82.8\* |          80.2\* |       89.8\* |             - |                        85.8 |
| ZeroBench        |         9 |     9\* |             3\* |          8\* |             - |                         4\* |
| ZeroBench（ツール使用） |        11 |     7\* |             9\* |         12\* |             - |                         3\* |
| OCRBench         |      92.3 |  80.7\* |          86.5\* |       90.3\* |             - |                        87.5 |
| OmniDocBench 1.5 |      88.8 |    85.7 |          87.7\* |         88.5 |             - |                      82.0\* |
| InfoVQA（val）     |      92.6 |    84\* |          76.9\* |       57.2\* |             - |                        89.5 |
| SimpleVQA        |      71.2 |  55.8\* |          69.7\* |       69.7\* |             - |                      56.8\* |
| WorldVQA         |      46.3 |    28.0 |            36.8 |         47.4 |             - |                        23.5 |
| VideoMMMU        |      86.6 |    85.9 |          84.4\* |         87.6 |             - |                        80.0 |
| MMVU             |      80.4 |  80.8\* |            77.3 |         77.5 |             - |                        71.1 |
| MotionBench      |      70.4 |    64.8 |            60.3 |         70.3 |             - |                           - |
| VideoMME         |      87.4 |  86.0\* |               - |       88.4\* |             - |                        79.0 |
| LongVideoBench   |      79.8 |  76.5\* |          67.2\* |       77.7\* |             - |                      65.6\* |
| LVBench          |      75.9 |       - |               - |       73.5\* |             - |                        63.6 |

#### コーディング

| ベンチマーク                 | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| ---------------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| SWE-Bench Verified     |      76.8 |    80.0 |            80.9 |         76.2 |          73.1 |                           - |
| SWE-Bench Pro          |      50.7 |    55.6 |          55.4\* |            - |             - |                           - |
| SWE-Bench Multilingual |      73.0 |    72.0 |            77.5 |         65.0 |          70.2 |                           - |
| Terminal Bench 2.0     |      50.8 |    54.0 |            59.3 |         54.2 |          46.4 |                           - |
| PaperBench             |      63.5 |  63.7\* |          72.9\* |            - |          47.1 |                           - |
| CyberGym               |      41.3 |       - |            50.6 |       39.9\* |        17.3\* |                           - |
| SciCode                |      48.7 |    52.1 |            49.5 |         56.1 |          38.9 |                           - |
| OJBench（cpp）           |      57.4 |       - |          54.6\* |       68.5\* |        54.7\* |                           - |
| LiveCodeBench（v6）      |      85.0 |       - |          82.2\* |       87.4\* |          83.3 |                           - |

#### 長文コンテキスト

| ベンチマーク       | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| ------------ | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| Longbench v2 |      61.0 |  54.5\* |          64.4\* |       68.2\* |        59.8\* |                           - |
| AA-LCR       |      70.0 |  72.3\* |          71.3\* |       65.3\* |        64.3\* |                           - |

#### エージェント検索

| ベンチマーク                          | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| ------------------------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| BrowseComp                      |      60.6 |    65.8 |            37.0 |         37.8 |          51.4 |                           - |
| BrowseComp（ctx 管理あり）            |      74.9 |    65.8 |            57.8 |         59.2 |          67.6 |                           - |
| BrowseComp（Agent Swarm）         |      78.4 |       - |               - |            - |             - |                           - |
| WideSearch（item-f1）             |      72.7 |       - |          76.2\* |         57.0 |        32.5\* |                           - |
| WideSearch（item-f1 Agent Swarm） |      79.0 |       - |               - |            - |             - |                           - |
| DeepSearchQA                    |      77.1 |  71.3\* |          76.1\* |       63.2\* |        60.9\* |                           - |
| FinSearchCompT2\&T3             |      67.8 |       - |          66.2\* |         49.9 |        59.1\* |                           - |
| Seal-0                          |      57.4 |    45.0 |          47.7\* |       45.5\* |        49.5\* |                           - |

#### 注記

* `*` = 著者によって再評価されたスコア（以前は公開されていなかったもの）。
* `†` = DeepSeek V3.2 のスコアは、脚注に記載のとおり、テキストのみのサブセットに対応します。
* `-` = 未評価 / 利用不可。


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/jp/moderu/tutorials/kimi-k2.5.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.