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

# Kimi K2.5

Déployez Kimi K2.5 (MoE multimodal 1T) de Moonshot AI sur les GPU Clore.ai

Kimi K2.5, sorti le 27 janvier 2026 par Moonshot AI, est un **modèle multimodal Mixture-of-Experts de 1 billion de paramètres** avec 32 milliards de paramètres actifs par jeton. Construit grâce à un pré-entraînement continu sur environ 15 billions de jetons visuels et textuels mélangés au-dessus de Kimi-K2-Base, il comprend nativement le texte, les images et la vidéo. K2.5 introduit **Agent Swarm** la technologie — coordonnant jusqu’à 100 agents IA spécialisés simultanément — et atteint des performances de pointe en codage (76,8 % SWE-bench Verified), en vision et sur les tâches agentiques. Disponible sous une **licence à poids ouverts** sur HuggingFace.

## Caractéristiques clés

* **1 billion au total / 32 milliards actifs** — architecture MoE à 384 experts avec attention MLA et SwiGLU
* **Multimodal natif** — pré-entraîné sur des jetons vision-langage ; comprend les images, la vidéo et le texte
* **Agent Swarm** — décompose les tâches complexes en sous-tâches parallèles via des agents créés dynamiquement
* **Fenêtre de contexte de 256K** — traite des bases de code entières, de longs documents et des transcriptions vidéo
* **Raisonnement hybride** — prend en charge à la fois le mode instantané (rapide) et le mode réflexion (raisonnement approfondi)
* **Codage performant** — 76,8 % SWE-bench Verified, 73,0 % SWE-bench Multilingual

## Exigences

Kimi K2.5 est un modèle massif — le checkpoint FP8 fait environ 630 Go. L’auto-hébergement nécessite du matériel sérieux.

| Composant | Quantifié (GGUF Q2)             | FP8 complet    |
| --------- | ------------------------------- | -------------- |
| GPU       | 1× RTX 4090 + 256 Go de RAM     | 8× H200 141 Go |
| VRAM      | 24 Go + déchargement sur le CPU | 1 128 Go       |
| RAM       | 256 Go et plus                  | 256GB          |
| Disque    | SSD de 400 Go                   | 700 Go NVMe    |
| CUDA      | 12.8+                           | 12.8+          |

**Recommandation de Clore.ai**: Pour un service en précision complète, louez 8× H200 ([bare metal](https://clore.ai/bare-metal)). Pour l’inférence locale quantifiée, un seul H100 80 Go, ou même une RTX 4090 avec un lourd déchargement sur CPU, fonctionne à vitesse réduite.

## Démarrage rapide avec llama.cpp (quantifié)

La façon la plus accessible d’exécuter K2.5 localement — en utilisant les quantifications GGUF d’Unsloth :

```bash
# Cloner et compiler llama.cpp
git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp
cmake -B build -DGGML_CUDA=ON && cmake --build build --config Release -j

# Télécharger le modèle quantifié (Q2_K_XL — 375 Go, bon compromis qualité/taille)
huggingface-cli download unsloth/Kimi-K2.5-GGUF \\
  Kimi-K2.5-UD-Q2_K_XL-00001-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00002-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00003-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00004-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00005-of-00005.gguf \\
  --local-dir ./models

# Exécuter l’inférence (ajustez --n-gpu-layers selon votre VRAM)
./build/bin/llama-server \\
  -m ./models/Kimi-K2.5-UD-Q2_K_XL-00001-of-00005.gguf \\
  --n-gpu-layers 10 \\
  --threads 32 \\
  --ctx-size 16384 \\
  --host 0.0.0.0 --port 8080
```

> **Remarque**: La vision n’est pas encore prise en charge dans GGUF/llama.cpp pour K2.5. Pour les fonctionnalités multimodales, utilisez vLLM.

## Configuration vLLM (production — modèle complet)

Pour un service en production avec prise en charge multimodale complète :

```bash
# Installer la version nightly de vLLM (K2.5 requiert la plus récente)
pip install -U vllm --pre \\
  --extra-index-url https://wheels.vllm.ai/nightly/cu129 \\
  --extra-index-url https://download.pytorch.org/whl/cu128 \\
  --index-strategy unsafe-best-match
```

### Déployer sur 8 GPU H200

```bash
vllm serve moonshotai/Kimi-K2.5 \\
  -tp 8 \\
  --mm-encoder-tp-mode data \\
  --tool-call-parser kimi_k2 \\
  --reasoning-parser kimi_k2 \\
  --trust-remote-code \\
  --gpu-memory-utilization 0.90
```

### Interroger avec du texte

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[
        {"role": "system", "content": "Vous êtes Kimi, un assistant IA créé par Moonshot AI."},
        {"role": "user", "content": "Rédigez un service FastAPI avec prise en charge WebSocket pour une conversation en temps réel"}
    ],
    temperature=0.6,
    max_tokens=4096
)
print(response.choices[0].message.content)
```

### Interroger avec une image (multimodal)

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY", timeout=3600)

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {"url": "https://example.com/diagram.png"}
            },
            {
                "type": "text",
                "text": "Décrivez ce diagramme en détail et extrayez tout le texte."
            }
        ]
    }],
    max_tokens=2048
)
print(response.choices[0].message.content)
```

## Accès à l’API (aucun GPU requis)

Si l’auto-hébergement est excessif, utilisez l’API officielle de Moonshot :

```python
from openai import OpenAI

# Plateforme Moonshot — API compatible avec OpenAI
client = OpenAI(
    api_key="your-moonshot-api-key",
    base_url="https://api.moonshot.ai/v1"
)

response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {"role": "user", "content": "Expliquez l’architecture Agent Swarm dans Kimi K2.5"}
    ],
    temperature=0.6,
    max_tokens=2048
)
print(response.choices[0].message.content)
```

## Appel d’outils

K2.5 excelle dans l’utilisation d’outils agentiques :

```python
import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

tools = [{
    "type": "function",
    "function": {
        "name": "search_code",
        "description": "Recherche dans une base de code les fichiers et fonctions pertinents",
        "parameters": {
            "type": "object",
            "required": ["query"],
            "properties": {
                "query": {"type": "string", "description": "Requête de recherche"}
            }
        }
    }
}]

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[{"role": "user", "content": "Trouvez tout le code lié à l’authentification dans le projet"}],
    tools=tools,
    tool_choice="auto",
    temperature=0.6
)

for tool_call in response.choices[0].message.tool_calls:
    print(f"Function: {tool_call.function.name}")
    print(f"Args: {json.loads(tool_call.function.arguments)}")
```

## Démarrage rapide avec Docker

```bash
# Utilisation de vLLM Docker avec 8 GPU
docker run --gpus all -p 8000:8000 \
  --ipc=host \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model moonshotai/Kimi-K2.5 \\
  --tensor-parallel-size 8 \
  --mm-encoder-tp-mode data \\
  --tool-call-parser kimi_k2 \\
  --reasoning-parser kimi_k2 \\
  --trust-remote-code
```

## Conseils pour les utilisateurs de Clore.ai

* **Compromis entre API et auto-hébergement**: K2.5 complet nécessite 8× H200 à [bare metal](https://clore.ai/bare-metal). L’API de Moonshot propose un niveau gratuit ou une tarification au jeton — utilisez l’API pour l’exploration, l’auto-hébergement pour des charges de production soutenues.
* **Quantifié sur un seul GPU**: Le GGUF Q2\_K\_XL d’Unsloth (\~375 Go) peut fonctionner sur une RTX 4090 (0,14–0,42 $/h) avec 256 Go de RAM via déchargement CPU — attendez-vous à \~5–10 tok/s. Suffisant pour un usage personnel et le développement.
* **K2 texte seul pour des configurations économiques**: Si vous n’avez pas besoin de la vision, `moonshotai/Kimi-K2-Instruct` est le prédécesseur texte seul — même MoE de 1T, mais plus léger à déployer (sans la surcharge de l’encodeur visuel).
* **Définissez correctement la température**: Utilisez `temperature=0.6` pour le mode instantané, `temperature=1.0` pour le mode réflexion. Une température incorrecte provoque des répétitions ou de l’incohérence.
* **Parallélisme des experts pour le débit**: Sur des configurations multinœuds, utilisez `--enable-expert-parallel` dans vLLM pour un débit plus élevé. Consultez la documentation vLLM pour la configuration de l’EP.

## Dépannage

| Problème                                       | Solution                                                                                                                     |
| ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` avec le modèle complet      | Nécessite 8× H200 (1128 Go au total). Utilisez des poids FP8, définissez `--gpu-memory-utilization 0.90`.                    |
| Inférence GGUF très lente                      | Assurez-vous d’avoir suffisamment de RAM pour la taille quantifiée. Q2\_K\_XL nécessite environ 375 Go de RAM+VRAM au total. |
| La vision ne fonctionne pas dans llama.cpp     | La prise en charge de la vision pour K2.5 GGUF n’est pas encore disponible — utilisez vLLM pour le multimodal.               |
| Sortie répétitive                              | Définissez `temperature=0.6` (instantané) ou `1.0` (réflexion). Ajoutez `min_p=0.01`.                                        |
| Le téléchargement du modèle prend une éternité | point de contrôle FP8 d’environ 630 Go. Utilisez `huggingface-cli download` avec `--resume-download`.                        |
| Appels d’outils non analysés                   | Ajoutez `--tool-call-parser kimi_k2 --enable-auto-tool-choice` à la commande de service vLLM.                                |

## Pour aller plus loin

* [Kimi K2.5 sur HuggingFace](https://huggingface.co/moonshotai/Kimi-K2.5)
* [Article technique sur Kimi K2.5](https://www.kimi.com/blog/kimi-k2-5.html)
* [Article de recherche sur Kimi K2.5](https://arxiv.org/abs/2602.02276)
* [Recette vLLM K2.5](https://docs.vllm.ai/projects/recipes/en/latest/moonshotai/Kimi-K2.5.html)
* [Quantifications GGUF d’Unsloth](https://huggingface.co/unsloth/Kimi-K2.5-GGUF)
* [Plateforme API Moonshot](https://platform.moonshot.ai)
* [GitHub Kimi K2](https://github.com/MoonshotAI/Kimi-K2)


---

# 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://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/kimi-k2.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.