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). 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 :

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

# 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

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, 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)

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 :

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 :

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

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

• Article technique sur Kimi K2.5

• Article de recherche sur Kimi K2.5

• Recette vLLM K2.5

• Quantifications GGUF d’Unsloth

• Plateforme API Moonshot

• GitHub Kimi K2