> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/modeles/tutorials/kimi-k2.5.md).

# Kimi K2.5 : guide pour l'exécuter localement

Kimi-K2.5 est le nouveau modèle de Moonshot qui atteint des performances SOTA dans les tâches de vision, de codage, agentiques et de chat. Le modèle de raisonnement hybride de 1 T de paramètres nécessite 600 Go d'espace disque, tandis que la version quantifiée **Unsloth Dynamic 1,8 bits** la version réduit cela à 240 Go (-60 % de taille)**:** [**Kimi-K2.5-GGUF**](https://huggingface.co/unsloth/Kimi-K2.5-GGUF)

Tous les téléversements utilisent Unsloth [Dynamique 2.0](/docs/fr/bases/unsloth-dynamic-2.0-ggufs.md) pour des performances SOTA sur Aider et MMLU en 5 shots. Voyez comment nos GGUF dynamiques 1–2 bits se comportent sur [benchmarks de codage](/docs/fr/bases/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md).

### :gear: Exigences recommandées

{% hint style="info" %}
Vous avez besoin de >**240 Go d'espace disque** pour exécuter la quantification 1 bit !

Pour de meilleures performances, assurez-vous que votre mémoire totale disponible (VRAM + RAM système) dépasse la taille du fichier de modèle quantifié que vous téléchargez. Si ce n'est pas le cas, llama.cpp peut quand même fonctionner via un déchargement SSD/HDD, mais l'inférence sera plus lente.
{% endhint %}

La quantification 1,8 bits (UD-TQ1\_0) fonctionnera sur un seul GPU de 24 Go si vous déchargez toutes les couches MoE dans la RAM système (ou sur un SSD rapide). Avec \~256 Go de RAM, comptez environ \~10 jetons/s. Le modèle complet Kimi K2.5 fait 630 Go et nécessite généralement au moins 4 GPU H200.

Si le modèle tient, vous obtiendrez >40 jetons/s avec un B200.

Pour exécuter le modèle en quasi **précision complète**, vous pouvez utiliser les quantifications 4 bits ou 5 bits. Vous pouvez utiliser n'importe quelle valeur supérieure pour plus de sécurité.

Pour de bonnes performances, visez >240 Go de mémoire unifiée (ou RAM+VRAM combinées) pour atteindre plus de 10 jetons/s. Si vous êtes en dessous, cela fonctionnera mais la vitesse diminuera (llama.cpp peut toujours fonctionner via mmap/déchargement sur disque) et peut passer d'environ \~10 jetons/s à <2 jetons/s.

Nous recommandons UD-Q2\_K\_XL (375 Go) comme bon compromis taille/qualité. Meilleure règle empirique : RAM+VRAM ≈ taille de la quantification ; sinon cela fonctionnera quand même, simplement plus lentement à cause du déchargement.

## 🥝 Guide pour exécuter Kimi K2.5

Kimi-K2.5 nécessite différents paramètres d'échantillonnage selon les cas d'utilisation.

Actuellement, il n'y a **aucun support de la vision** pour le modèle, mais espérons que llama.cpp le prendra bientôt en charge.

{% hint style="success" %}
**Pour exécuter le modèle en précision complète, il suffit d'utiliser les GGUF dynamiques 4 bits ou 5 bits (p. ex. UD\_Q4\_K\_XL) car le modèle a été publié à l'origine au format INT4.**

Vous pouvez choisir une quantification en bits plus élevée pour plus de sécurité en cas de petites différences de quantification, mais dans la plupart des cas cela est inutile.
{% endhint %}

### 🌙 Guide d'utilisation :

Selon Moonshot AI, voici les paramètres recommandés pour l'inférence de Kimi K2.5 :

| Paramètres par défaut (mode instantané)                            | Mode de réflexion                                                  |
| ------------------------------------------------------------------ | ------------------------------------------------------------------ |
| <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                                                      |

* Réglez la **température à 1,0** pour réduire la répétition et l'incohérence.
* Longueur de contexte suggérée = 98 304 (jusqu'à 256 K)
* Note : l'utilisation de différents outils peut nécessiter des réglages différents

{% hint style="info" %}
Nous recommandons de régler <mark style="background-color:green;">**min\_p à 0.01**</mark> pour supprimer l'apparition de jetons improbables avec de faibles probabilités. Et **désactivez ou réglez la pénalité de répétition = 1,0** si nécessaire.
{% endhint %}

#### Modèle de chat pour Kimi K2.5

Exécution `tokenizer.apply_chat_template([{"role": "user", "content": "What is 1+1?"},])` donne :

{% code overflow="wrap" %}

```
<|im_system|>system<|im_middle|>Vous êtes Kimi, un assistant IA créé par Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Que vaut 1+1 ?<|im_end|><|im_assistant|>assistant<|im_middle|><think>
```

{% endcode %}

#### 🦥 Exécutez Kimi-K2.5 dans Unsloth Studio

Kimi-K2.5 peut être exécuté dans [Unsloth Studio](/docs/fr/nouveau/studio.md), notre nouvelle interface web open source pour l'IA locale. Avec Unsloth Studio, vous pouvez exécuter des modèles localement sur **MacOS, Windows**, Linux et :

{% columns %}
{% column %}

* Rechercher, télécharger, [exécuter des GGUF](/docs/fr/nouveau/studio.md#run-models-locally) et des modèles safetensor
* [**Appels d'outils auto-réparateurs** appels d'outils](/docs/fr/nouveau/studio.md#execute-code--heal-tool-calling) + **recherche web**
* [**Exécution de code**](/docs/fr/nouveau/studio.md#run-models-locally) (Python, Bash)
* [Inférence automatique](/docs/fr/nouveau/studio.md#model-arena) réglage des paramètres (temp, top-p, etc.)
* Inférence rapide CPU + GPU via llama.cpp
* [Entraîner des LLM](/docs/fr/nouveau/studio.md#no-code-training) 2x plus vite avec 70 % de VRAM en moins
  {% endcolumn %}

{% column %}

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

{% stepper %}
{% step %}
**Installer Unsloth**

Exécutez dans votre terminal :

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" %}
**L'installation sera rapide et prendra environ 1 à 2 minutes.**
{% endhint %}
{% endstep %}

{% step %}
**Lancer Unsloth**

MacOS, Linux, WSL et Windows :

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

Puis ouvrez `http://localhost:8888` dans votre navigateur.
{% endstep %}

{% step %}
**Recherchez et téléchargez Kimi-K2.5**

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

Puis allez dans l’ [Unsloth Chat](/docs/fr/nouveau/studio/chat.md) onglet et recherchez **Kimi-K2.5** dans la barre de recherche, puis téléchargez le modèle et la quantification de votre choix. Assurez-vous de disposer de suffisamment de ressources de calcul pour exécuter le modèle.

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

{% step %}
**Exécutez Kimi-K2.5**

Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio, mais vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur du contexte, le modèle de chat et d’autres paramètres.

Pour plus d'informations, vous pouvez consulter notre [guide d'inférence Unsloth Studio](/docs/fr/nouveau/studio/chat.md).

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

### ✨ Exécutez Kimi K2.5 dans llama.cpp

Pour ce guide, nous utiliserons la plus petite quantification 1 bit, qui fait 240 Go. N'hésitez pas à changer le type de quantification en 2 bits, 3 bits, etc. Pour exécuter le modèle en quasi **précision complète**, vous pouvez utiliser les quantifications 4 bits ou 5 bits. Vous pouvez utiliser n'importe quelle valeur supérieure pour plus de sécurité.

1. Obtenez la dernière `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez également suivre les instructions de compilation ci-dessous. Modifiez `-DGGML_CUDA=ON` à `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d'habitude - la prise en charge de Metal est activée par défaut.

```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. Si vous souhaitez utiliser `llama.cpp` directement pour charger des modèles, vous pouvez faire ce qui suit : (:UD-TQ1\_0) est le type de quantification. Vous pouvez également télécharger via Hugging Face (point 3). C'est similaire à `ollama run` . Utilisez `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` pour enregistrer dans un emplacement spécifique.

{% hint style="success" %}
`LLAMA_SET_ROWS=1` rend llama.cpp un peu plus rapide ! Utilisez-le ! `--fit sur` adapte automatiquement les modèles de manière optimale sur tous vos GPU et 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 sur` ajustera automatiquement le modèle à votre système. Si vous n'utilisez pas `--fit sur` et que vous disposez d'environ 360 Go de mémoire GPU combinée, supprimez `-ot ".ffn_.*_exps.=CPU"` pour obtenir la vitesse maximale.

{% hint style="info" %}
Utilisez `--fit sur` pour l'ajustement automatique sur GPU et CPU. Si cela ne fonctionne pas, consultez ci-dessous :

Veuillez essayer `-ot ".ffn_.*_exps.=CPU"` pour décharger toutes les couches MoE sur le CPU ! Cela vous permet effectivement de faire tenir toutes les couches non-MoE sur 1 GPU, ce qui améliore les vitesses de génération. Vous pouvez personnaliser l'expression regex pour faire tenir davantage de couches si vous avez 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.

Et enfin, déchargez toutes les couches via `-ot ".ffn_.*_exps.=CPU"` Cela utilise le moins de VRAM.

Vous pouvez aussi personnaliser l’expression régulière, par exemple `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` signifie de décharger les couches MoE gate, up et down, mais uniquement à partir de la 6e couche.
{% endhint %}

3. Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer` ). Nous recommandons d'utiliser notre quantification dynamique 2 bits UD-Q2\_K\_XL pour équilibrer taille et précision. Toutes les versions sur : [huggingface.co/unsloth/Kimi-K2.5-GGUF](https://huggingface.co/unsloth/Kimi-K2.5-GGUF) Si les téléchargements se bloquent, consultez [Dépannage Hugging Face Hub, XET](/docs/fr/bases/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*" # Utilisez "*UD-Q2_K_XL*" pour la quantification dynamique 2 bits
```

{% endcode %}

{% hint style="info" %}
Si vous constatez que les téléchargements restent bloqués autour de 90 à 95 %, veuillez consulter notre [guide de dépannage](https://docs.unsloth.ai/basics/troubleshooting-and-faqs#downloading-gets-stuck-at-90-to-95).
{% endhint %}

4. Essayez n'importe quelle invite.
5. Modifier  `--ctx-size 16384` pour la longueur de contexte. Vous pouvez aussi l'omettre pour une détection automatique de la longueur du contexte via `--fit sur`

{% 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. À titre d'exemple, essayez : « Crée un jeu Flappy Bird en HTML », et vous obtiendrez :

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

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

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

```html
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flappy Bird</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>
        
        <!-- Écran de démarrage -->
        <div id="start-screen" class="overlay">
            <div class="game-title">FLAPPY BIRD</div>
            <div class="instruction">Cliquez ou appuyez sur Espace pour voler</div>
        </div>
        
        <!-- Écran de fin de partie -->
        <div id="game-over-screen" class="overlay hidden">
            <div class="game-title">PARTIE TERMINÉE</div>
            <div class="score-display">Score : <span id="final-score">0</span></div>
            <div class="best-score">Meilleur : <span id="best-score">0</span></div>
            <div class="instruction">Cliquez pour recommencer</div>
        </div>
        
        <!-- Compteur de score -->
        <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');
        
        // Constantes du jeu
        const GRAVITY = 0.4;
        const JUMP_STRENGTH = -7;
        const PIPE_SPEED = 3;
        const PIPE_SPAWN_RATE = 120; // images
        const PIPE_GAP = 120;
        
        // État du jeu
        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;
        
        // Éléments du 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');
        
        // Gestion des entrées
        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;
            
            // Physique de l'oiseau
            bird.velocity += GRAVITY;
            bird.y += bird.velocity;
            
            // Collision avec le sol/plafond
            if (bird.y + bird.radius > canvas.height || bird.y - bird.radius < 0) {
                gameOver();
                return;
            }
            
            // Apparition des tuyaux
            frameCount++;
            if (frameCount % PIPE_SPAWN_RATE === 0) {
                spawnPipe();
            }
            
            // Mouvement des tuyaux et collision
            for (let i = pipes.length - 1; i >= 0; i--) {
                const pipe = pipes[i];
                pipe.x -= PIPE_SPEED;
                
                // Suppression des tuyaux hors écran
                if (pipe.x + 60 < 0) {
                    pipes.splice(i, 1);
                    continue;
                }
                
                // Détection de collision (rectangle-cercle simplifiée)
                const pipeWidth = 60;
                const pipeX = pipe.x;
                const pipeLeft = pipeX;
                const pipeRight = pipeX + pipeWidth;
                
                // L'oiseau est un cercle, les tuyaux sont des rectangles
                const birdLeft = bird.x - bird.radius + 4; // +4 pour le décalage du bec
                const birdRight = bird.x + bird.radius + 2;
                const birdTop = bird.y - bird.radius;
                const birdBottom = bird.y + bird.radius;
                
                // Vérification de collision horizontale
                if (birdRight > pipeLeft && birdLeft < pipeRight) {
                    // Collision avec le tuyau du haut
                    if (birdTop < pipe.topHeight) {
                        gameOver();
                        return;
                    }
                    // Collision avec le tuyau du bas
                    if (birdBottom > pipe.bottomY) {
                        gameOver();
                        return;
                    }
                }
                
                // Comptage des points
                if (pipe.x + pipeWidth < bird.x && !pipe.passued) {
                    pipe.passed = true;
                    score++;
                    currentScoreDisplay.textContent = score;
                }
            }
            
            // Animation des ailes
            if (bird.wingState > 0) {
                bird.wingState = (bird.wingState + 0.2) % 2;
            }
        }
        
        function draw() {
            // Effacer le canvas
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // Dessiner les tuyaux
            pipes.forEach(pipe => {
                // Tuyau supérieur
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, 0, 60, pipe.topHeight);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.topHeight - 20, 60, 20); // Bouchon
                
                // Tuyau inférieur
                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); // Bouchon
            });
            
            // Dessiner l'oiseau (cercle avec bec)
            ctx.fillStyle = '#e3bc4e';
            ctx.beginPath();
            ctx.arc(bird.x, bird.y, bird.radius, 0, Math.PI * 2);
            ctx.fill();
            
            // Bec
            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();
            
            // Yeux
            ctx.fillStyle = 'black';
            ctx.beginPath();
            ctx.arc(bird.x + 5, bird.y - 6, 3, 0, Math.PI * 2);
            ctx.fill();
            
            // Ailes
            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;
            
            // Mettre à jour le meilleur score
            if (score > bestScore) {
                bestScore = score;
                localStorage.setItem('flappyBest', bestScore);
            }
            
            // Afficher l'écran de fin de partie
            currentScoreDisplay.classList.add('hidden');
            gameOverScreen.classList.remove('hidden');
            finalScoreEl.textContent = score;
            bestScoreEl.textContent = bestScore;
        }
        
        function gameLoop() {
            if (!isPlaying) return;
            
            update();
            draw();
            requestAnimationFrame(gameLoop);
        }
        
        // Dessin initial
        draw();
    </script>
</body>
</html>
```

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

### ✨ Déployez avec llama-server et la bibliothèque de complétion d'OpenAI

{% hint style="success" %}
En utilisant `--kv-unified` peut rendre le service d'inférence plus rapide dans llama.cpp ! Voir <https://www.reddit.com/r/LocalLLaMA/comments/1qnwa33/glm_47_flash_huge_performance_improvement_with_kvu/>
{% endhint %}

Après avoir installé llama.cpp conformément à [#run-kimi-k2-thinking-in-llama.cpp](#run-kimi-k2-thinking-in-llama.cpp "mention"), vous pouvez utiliser ce qui suit pour lancer un serveur compatible 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 %}

Puis utilisez la bibliothèque Python d'OpenAI après `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": "What is 1+1?"},],
)
print(completion.choices[0].message.content)
```

Et nous obtenons :

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

Et dans l'autre écran llama-server :

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

### 📊 Benchmarks

Vous pouvez voir plus bas les benchmarks sous forme de tableau :

<figure><img src="/files/49c4b9300f2b0ce1997adb646035c4f443469bb1" alt="" width="375"><figcaption></figcaption></figure>

#### Raisonnement et connaissances

| Benchmark              | Kimi K2.5 | GPT-5.2 | Claude 4.5 Opus | Gemini 3 Pro | DeepSeek V3.2 | Qwen3-VL-235B-A22B-Thinking |
| ---------------------- | --------: | ------: | --------------: | -----------: | ------------: | --------------------------: |
| HLE-Full               |      30.1 |    34.5 |            30.8 |         37.5 |         25,1† |                           - |
| HLE-Full (avec outils) |      50.2 |    45.5 |            43.2 |         45.8 |         40,8† |                           - |
| AIME 2025              |      96.1 |     100 |            92.8 |         95.0 |          93.1 |                           - |
| HMMT 2025 (févr.)      |      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 |                           - |

#### Image et vidéo

| Benchmark               | 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 (avec outils) |        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 |

#### Programmation

| Benchmark              | 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 |                           - |

#### Contexte long

| Benchmark    | 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\* |                           - |

#### Recherche agentique

| Benchmark                             | 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 (avec gestion du contexte) |      74.9 |    65.8 |            57.8 |         59.2 |          67.6 |                           - |
| BrowseComp (essaim d’agents)          |      78.4 |       - |               - |            - |             - |                           - |
| WideSearch (item-f1)                  |      72.7 |       - |          76.2\* |         57.0 |        32.5\* |                           - |
| WideSearch (essaim d’agents item-f1)  |      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\* |                           - |

#### Notes

* `*` = score réévalué par les auteurs (non disponible publiquement auparavant).
* `†` = le score de DeepSeek V3.2 correspond à son sous-ensemble uniquement textuel (comme indiqué dans les notes de bas de page).
* `-` = non évalué / non disponible.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://unsloth.ai/docs/fr/modeles/tutorials/kimi-k2.5.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.