# Kimi K2.5 Kimi K2.5, publié le 27 janvier 2026 par Moonshot AI, est un **modèle multimodal Mixture-of-Experts d'un trillion de paramètres** avec 32 milliards de paramètres actifs par token. Construit via un pré-entraînement continu sur \~15 trillions de tokens mixtes visuels et textuels par-dessus le Kimi-K2-Base, il comprend nativement le texte, les images et la vidéo. K2.5 introduit **Agent Swarm** technologie — coordonnant jusqu'à 100 agents d'IA spécialisés simultanément — et atteint des performances de pointe en codage (76,8 % SWE-bench Verified), vision et tâches agentiques. Disponible sous une **licence à poids ouvert** sur HuggingFace. ## Principales caractéristiques * **1T total / 32B actifs** — architecture MoE à 384 experts avec attention MLA et SwiGLU * **Multimodal natif** — pré-entraîné sur des tokens 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 générés dynamiquement * **fenêtre de contexte 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 profond) * **Excellente performance en codage** — 76,8 % SWE-bench Verified, 73,0 % SWE-bench Multilingue ## Exigences Kimi K2.5 est un modèle massif — le point de contrôle FP8 fait \~630 Go. L'hébergement autonome 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 CPU | 1 128 Go | | RAM | 256 Go+ | 256GB | | Disque | SSD 400 Go | NVMe 700 Go | | CUDA | 12.0+ | 12.0+ | **Recommandation Clore.ai**: Pour un service en précision complète, louez 8× H200 (\~24–48 $/jour). Pour l'inférence locale quantifiée, un seul H100 80 Go ou même une RTX 4090 avec un fort déchargement CPU fonctionne à vitesse réduite. ## Démarrage rapide avec llama.cpp (Quantifié) Le moyen le 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 # Lancer 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 le service en production avec prise en charge multimodale complète : ```bash # Installer vLLM nightly (K2.5 nécessite la version 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/cu129 \ --index-strategy unsafe-best-match ``` ### Servir 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, une assistante IA créée par Moonshot AI."}, {"role": "user", "content": "Écrivez un service FastAPI avec prise en charge WebSocket pour le chat 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 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 OpenAI client = OpenAI( api_key="votre-cle-api-moonshot", 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 agentique d'outils : ```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": "Rechercher 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 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 * **Choix entre API et auto-hébergement**: Le K2.5 complet nécessite 8× H200 à \~24–48 $/jour. L'API de Moonshot propose un niveau gratuit ou pay-per-token — utilisez l'API pour l'exploration, auto-hébergez pour des charges de production soutenues. * **Quantifié sur un seul GPU**: L'Unsloth GGUF Q2\_K\_XL (\~375 Go) peut fonctionner sur une RTX 4090 (0,5–2 $/jour) 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 uniquement texte pour configurations économiques**: Si vous n'avez pas besoin de la vision, `moonshotai/Kimi-K2-Instruct` est le prédécesseur uniquement texte — même MoE à 1T mais plus léger à déployer (sans surcharge d'encodeur vision). * **Configurer correctement la température**: Utilisez `temperature=0.6` pour le mode instantané, `temperature=1.0` pour le mode réflexion. Une mauvaise température cause répétition ou incohérence. * **Parallelisme d'experts pour le débit**: Sur des configurations multi-nœuds, utilisez `--enable-expert-parallel` dans vLLM pour un débit plus élevé. Consultez la documentation vLLM pour la configuration EP. ## Dépannage | Problème | Solution | | ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | | `OutOfMemoryError` avec le modèle complet | Nécessite 8× H200 (1 128 Go au total). Utilisez des poids FP8, définissez `--gpu-memory-utilization 0.90`. | | Inference GGUF très lente | Assurez-vous d'avoir suffisamment de RAM pour la taille quantifiée. Q2\_K\_XL nécessite \~375 Go RAM+VRAM combinés. | | La vision ne fonctionne pas dans llama.cpp | Le support vision pour K2.5 GGUF n'est pas encore disponible — utilisez vLLM pour le multimodal. | | Sortie répétitive | Définir `temperature=0.6` (instantané) ou `1.0` (réflexion). Ajoutez `min_p=0.01`. | | Le téléchargement du modèle prend une éternité | \~630 Go point de contrôle FP8. Utilisez `huggingface-cli download` avec `--resume-download`. | | Appels d'outils non analysés | Ajoutez `--tool-call-parser kimi_k2 --enable-auto-tool-choice` au commande vLLM serve. | ## Lectures complémentaires * [Kimi K2.5 sur HuggingFace](https://huggingface.co/moonshotai/Kimi-K2.5) * [Blog technique Kimi K2.5](https://www.kimi.com/blog/kimi-k2-5.html) * [Article 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 Unsloth GGUF](https://huggingface.co/unsloth/Kimi-K2.5-GGUF) * [Plateforme API Moonshot](https://platform.moonshot.ai) * [Kimi K2 GitHub](https://github.com/MoonshotAI/Kimi-K2)