> 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/kimi-k2.7-code.md).

# Kimi K2.7 Code - Comment l'exécuter localement

Kimi K2.7 Code est le modèle de codage agentique de Moonshot AI, s’appuyant sur [K2.6](/docs/fr/modeles/kimi-k2.6.md) pour améliorer l’achèvement des tâches tout en utilisant environ 30 % de jetons de réflexion en moins. Le modèle MoE de 1T de paramètres (32B actifs) prend en charge uniquement la réflexion, la vision et un contexte de 256K. Il offre des performances open SOTA sur les tâches de vision, de codage, agentiques, à long contexte et de chat. La précision complète nécessite 605 Go d’espace disque ; Unsloth [Dynamique](/docs/fr/bases/unsloth-dynamic-2.0-ggufs.md) Le 2 bits nécessite **325 Go (-48 %)**. Exécutez [**Kimi-K2.7-Code-GGUF**](https://huggingface.co/unsloth/Kimi-K2.7-Code-GGUF) via Unsloth Studio ou llama.cpp.

[**Unsloth Dynamique**](/docs/fr/bases/unsloth-dynamic-2.0-ggufs.md) **quantifications** met à niveau les couches importantes en 8 bits et nécessite **310 Go+ VRAM/RAM** configurations**.** Pour **sans perte** Pour Kimi K2.6, utilisez Q8 (`UD-Q8_K_XL`), qui n'est que **10 Go de plus** que Q4 (`UD-Q4_K_XL`). Vous pouvez exécuter Kimi K2.7 Code via un Mac Studio ou [DGX Station](/docs/fr/blog/dgx-station.md).

**Tableau : exigences matérielles** (unités = mémoire totale : RAM + VRAM, ou mémoire unifiée)

| 1 bit dynamique | Dynamique 2 bits | Q3 dynamique | Q8 (sans perte) |
| --------------- | ---------------- | ------------ | --------------- |
| 310 Go          | 325-350 Go       | 385-470 Go   | 605 Go          |

### 📊 Analyse de quantification

Comme [Kimi-K2.6](/docs/fr/modeles/kimi-k2.6.md), `UD-Q8_K_XL` est sans perte car Kimi utilise int4 pour les poids MoE et BF16 pour tout le reste, et `Q8_K_XL` en découle. Ainsi, nous utilisons la même méthodologie dynamique pour la conversion de Kimi-K2.6. `UD-Q4_K_XL` est similaire, sauf que les tenseurs restants sont `Q8_0`, donc il est presque en précision complète et nécessite 600 Go de RAM/VRAM. `UD-Q8_K_XL` est « véritablement sans perte ».

| Mesure        | UD-Q2\_K\_XL | UD-Q4\_K\_XL | UD-Q8\_K\_XL (sans perte) |
| ------------- | ------------ | ------------ | ------------------------- |
| Espace disque | 339 Go       | 584 Go       | 595 Go                    |
| Perplexité    | \~2.4131     | \~1.8420     | \~1.8419                  |

Nous avons suivi [jukofyork](https://github.com/jukofyork)a découvert que `const float d = max / -7;` au lieu de la valeur par défaut `const float d = max / -8;` pendant le processus de quantification uniquement sur les couches MoE. Ce correctif de bijection sur les MoE natives INT4 permet au `Q4_0` type de quantification de réduire l'erreur absolue de 1,8 % à presque 0 % (epsilon). Par exemple, ci-dessous se trouve l'histogramme pour Kimi-K2.7-Code, et vous pouvez voir que -8 n'est absolument pas utilisé :

<figure><img src="/files/7b976d647b9e4d9a81c4a292e28fbc45ac3ddcc6" alt=""><figcaption></figcaption></figure>

Notez que nous devons également conserver les autres couches en BF16 et ne pas utiliser le « Q4\_0 » intelligent. Nous montrons ci-dessous les graphiques d'erreur pour les deux par rapport à la base BF16. `UD-Q8-K_XL` est vraiment « sans perte », avec une différence de l'ordre de l'epsilon machine lors de la conversion de Q4\_0 vers BF16. Ainsi, Q4\_K\_XL présente bien une certaine erreur de quantification due à l'utilisation de Q8\_0, tandis que Q8\_K\_XL est presque sans perte, sauf pour l'arrondi BF16.

<figure><img src="/files/b96158e5a2dd307aa5a0ff4002cf1098e22dcd84" alt=""><figcaption></figcaption></figure>

Pour Q4\_K\_XL, nous traçons également l'erreur par tenseur de Q8\_0 par rapport à BF16. En général, il existe une certaine erreur entre Q8\_K\_XL (presque sans perte) et Q4\_K\_XL, mais pas beaucoup.

<figure><img src="/files/e7b64c71af3efca3dfcffae959133e227389eaed" alt=""><figcaption></figcaption></figure>

### :gear: Guide d'utilisation

Kimi K2.7 Code est **réflexion uniquement**, avec **`preserve_thinking` toujours activé**. Le mode instantané n’est pas pris en charge.

| Par défaut (mode réflexion) |
| --------------------------- |
| temperature = 1.0           |
| top\_p = 0,95               |

* Longueur de contexte suggérée = `98,304` (jusqu’à `262,144`)

Si le modèle tient en mémoire, vous obtiendrez >100 jetons/s avec des B200. Nous recommandons `UD-Q2_K_XL` (345 Go) comme bon compromis taille/qualité. Meilleure règle empirique : RAM+VRAM ≈ la taille de la quantification ; sinon, cela fonctionnera quand même, mais plus lentement à cause du déchargement.

#### Gabarit de chat pour Kimi K2.7-Code

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

{% code overflow="wrap" %}

```
<|im_user|>user<|im_middle|>Combien font 1+1 ?<|im_end|><|im_assistant|>assistant<|im_middle|><think>
```

{% endcode %}

Si nous saisissons également les outils comme référencés dans [Tool Calling Guide](/docs/fr/bases/tool-calling-guide-for-local-llms.md), alors voici ce que l’on obtient :

{% code overflow="wrap" expandable="true" %}

```
<|im_system|>tool_declare<|im_middle|># Outils

## fonctions
namespace functions {
// Additionner deux nombres.
type add_number = (_: {
  // Le premier nombre.
  a: string,
  // Le deuxième nombre.
  b: string
}) => any;
// Multiplier deux nombres.
type multiply_number = (_: {
  // Le premier nombre.
  a: string,
  // Le deuxième nombre.
  b: string
}) => any;
// Soustraire deux nombres.
type subtract_number = (_: {
  // Le premier nombre.
  a: string,
  // Le deuxième nombre.
  b: string
}) => any;
// Écrire une histoire aléatoire.
type write_a_story = (_: {}) => any;
// Effectuer des opérations dans le terminal.
type terminal = (_: {
  // La commande que vous souhaitez lancer, par ex. `ls`, `rm`, ...
  command: string
}) => any;
// Appeler un interpréteur Python avec du code Python qui sera exécuté.
type python = (_: {
  // Le code Python à exécuter
  code: string
}) => any;
}
<|im_end|><|im_user|>user<|im_middle|>Combien font 1+1 ?<|im_end|><|im_assistant|>assistant<|im_middle|><think>
```

{% endcode %}

## Guide d’exécution de Kimi K2.7 Code

### 🦥 Exécuter Kimi-K2.7-Code dans Unsloth Studio

Kimi K2.7 Code peut s’exécuter dans [Unsloth Studio](/docs/fr/nouveau/studio.md), une interface web open source pour l’IA locale. **Unsloth Studio décharge automatiquement vers la RAM et détecte les configurations multi-GPU**. 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 et lancer Unsloth**

Pour l’installer, 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
```

**Lancer Unsloth**

MacOS, Linux, WSL et Windows :

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

Puis ouvrez `http://127.0.0.1:8888` (ou votre URL spécifique) dans votre navigateur.
{% endstep %}

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

Unsloth Studio décharge automatiquement vers la RAM et détecte les configurations multi-GPU. Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard.

Puis allez dans l’ [Unsloth Chat](/docs/fr/nouveau/studio/chat.md) onglet et recherchez **Kimi-K2.7 Code** dans la barre de recherche et téléchargez le modèle et la quantification souhaités. Assurez-vous d’avoir suffisamment de puissance de calcul pour exécuter le modèle.

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

{% step %}
**Exécuter Kimi-K2.7-Code**

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/acbddf2b13951f7e83eb5a222093fd827a4b5258" alt="" width="563"><figcaption><p>Exemple de Qwen3.6 fonctionnant avec appel d’outils</p></figcaption></figure></div>
{% endstep %}
{% endstepper %}

### 🦙 Exécuter Kimi K2.7 Code dans llama.cpp

Pour ce guide, nous allons exécuter le `UD-Q2_K_XL` quant qui nécessitera au moins 345 Go de RAM. N’hésitez pas à modifier le type de quantification. GGUF : [**Kimi-K2.7-Code-GGUF**](https://huggingface.co/unsloth/Kimi-K2.7-Code-GGUF)

Pour ces tutoriels, nous utiliserons [llama.cpp](llama.cpphttps://github.com/ggml-org/llama.cpp) pour une inférence locale rapide, surtout si vous avez un CPU.

{% stepper %}
{% step %}
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
```

{% endstep %}

{% step %}
**Prenons d’abord une image !** Vous pouvez également téléverser des images. Nous utiliserons <https://raw.githubusercontent.com/unslothai/unsloth/refs/heads/main/images/unsloth%20made%20with%20love.png>, qui n’est que notre mini-logo montrant comment les fine-tunes sont réalisés avec Unsloth :

{% code overflow="wrap" %}

```bash
wget https://raw.githubusercontent.com/unslothai/unsloth/refs/heads/main/images/unsloth%20made%20with%20love.png -O unsloth.png
```

{% endcode %}

<figure><img src="/files/8226e799b1a697c94669626a5da8371ee8388470" alt="" width="188"><figcaption></figcaption></figure>

Prenons aussi la 2e image à <https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg>

{% code overflow="wrap" %}

```bash
wget https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg -O picture.png
```

{% endcode %}

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

{% step %}
Vous pouvez maintenant utiliser `llama.cpp` directement pour charger et télécharger des modèles, tout comme `ollama run`. Tout d'abord, sélectionnez le type de quantification que vous souhaitez, comme `Q2_K_XL`. Utilisez aussi `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` l'enregistrement dans un emplacement spécifique. Notez que ce processus de téléchargement peut être très lent, il est donc probablement préférable d'utiliser le processus de téléchargement manuel dans la section suivante.

```bash
export LLAMA_CACHE="unsloth/Kimi-K2.7-Code-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Kimi-K2.7-Code-GGUF:UD-Q2_K_XL \\
    --temp 1.0 \
    --top-p 0.95
```

{% endstep %}

{% step %}
Si vous souhaitez télécharger le modèle manuellement, nous pouvons le télécharger via le code ci-dessous (après avoir installé `pip install huggingface_hub`). Si les téléchargements restent bloqués, voir : [Hugging Face Hub, débogage XET](/docs/fr/bases/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

```bash
hf download unsloth/Kimi-K2.7-Code-GGUF \\
    --local-dir unsloth/Kimi-K2.7-Code-GGUF \\
    --include "*mmproj-F16*" \\
    --include "*UD-Q2_K_XL*" # Utilisez "*UD-Q8_K_XL*" pour la précision complète
```

{% endstep %}

{% step %}
Puis exécutez le modèle en mode conversation :

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \\
    --model unsloth/Kimi-K2.7-Code-GGUF/UD-Q2_K_XL/Kimi-K2.7-Code-UD-Q2_K_XL-00001-of-00008.gguf \\
    --mmproj unsloth/Kimi-K2.7-Code-GGUF/mmproj-F16.gguf \\
    --temp 1.0 \
    --top-p 0.95
```

{% endcode %}

Vous verrez alors ce qui suit :\
![](/files/e6af1d459bcfdf53b2e2457b268ac8b1ba9cce95)
{% endstep %}

{% step %}
Ensuite, utilisez `/image` pour charger les deux images et demander « Quelle est cette image » :

<figure><img src="/files/293e043d360bafc05607d13d403ce69ebd8b5bb8" alt=""><figcaption></figcaption></figure>

et vous obtiendrez quelque chose comme ci-dessous :

<figure><img src="/files/222b0cb3d6f4bff9098a9b3997e6f2d77e619237" alt=""><figcaption></figcaption></figure>

Sur la 2e image du paresseux :

<figure><img src="/files/0fbf40a1fb039b839019a79dcf7367eea9ca95bf" alt=""><figcaption></figcaption></figure>

Ce qui vous donnera :

<figure><img src="/files/0d381287e2e61e78d5f5c9d3bca19555fdab0baf" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

### 📊 Benchmarks

Vous pouvez consulter ci-dessous d’autres benchmarks sous forme de tableau :

<div data-with-frame="true"><figure><img src="/files/9722c6772805327e152980b803bf3a4a22879947" alt="" width="563"><figcaption></figcaption></figure></div>

|          Benchmark          | Kimi K2.7 Code | Kimi K2.6 | GPT-5.5 | Claude Opus 4.8 |
| :-------------------------: | :------------: | :-------: | :-----: | :-------------: |
|          **Codage**         |                |           |         |                 |
|      Kimi Code Bench v2     |      62.0      |    50.9   |   69.0  |       67.4      |
|  Banc d’essai de programme  |      53.6      |    48.3   |   69.1  |       63.8      |
|        MLS Bench Lite       |      35.1      |    26.7   |   35.5  |       42.8      |
|        **Agentique**        |                |           |         |                 |
| Banc d’essai Kimi Claw 24/7 |      46.9      |    42.9   |   52.8  |       50.4      |
|          MCP Atlas          |      76.0      |    69.4   |   79.4  |       81.3      |
|       MCP Mark vérifié      |      81.1      |    72.8   |   92.9  |       76.4      |


---

# 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/kimi-k2.7-code.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.