> 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 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) --- # 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: ``` GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/kimi-k2.md?ask= ``` 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.