Kimi K2.5

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

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 :

# 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 :

# 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

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

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)

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 :

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 :

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

# 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

• Blog technique Kimi K2.5

• Article Kimi K2.5

• Recette vLLM K2.5

• Quantifications Unsloth GGUF

• Plateforme API Moonshot

• Kimi K2 GitHub