Kimi K2.5 est le modèle agentique multimodal natif et open source de Moonshot AI, construit par pré-entraînement continu sur environ 15T tokens mixtes visuels et textuels au-dessus de Kimi-K2-Base.
- Entrée
- texte image vidéo $0.574/M
- Sortie
- texte $3.011/M
- Lecture de cache
- $0.115/M
- Contexte
- 262K
- vs GPT-4o
- ~89% moins cher
Benchmarks
Chiffres publiés par les fournisseurs : Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Le prix en contexte
Position du prix parmi 60 modèles comparables
La barre montre où se situe le prix de ce modèle parmi tous les modèles du même type sur Synthorai. Le moins cher et le plus cher sont nommés à chaque extrémité. Ce sont des tarifs de base ; les remises lot, région et écriture en cache figurent sur la page des tarifs.
Spécifications et limites
Tokens
| Fenêtre de contexte (spécification du fournisseur) | 256 000 |
|---|
Mise en cache
| Mode | automatique |
|---|
Raisonnement
| Paramètre du fournisseur | thinking.type |
|---|---|
| Valeurs acceptées | enabled · disabled |
| Valeur par défaut | enabled sur la plateforme de Moonshot ; à noter qu'Alibaba Model Studio documente son déploiement de ce modèle avec la réflexion désactivée par défaut appliquée si la requête ne précise rien |
| Désactivable | Oui |
| Comportement du raisonnement | La trace revient dans reasoning_content, compte dans max_tokens et est toujours diffusée avant content ; Preserved Thinking n'est pas pris en charge, mais le reasoning_content historique doit être conservé dans messages, sinon le modèle perd son contexte de raisonnement. |
| Paramètre | reasoning_effort |
| Valeurs | minimal · low · medium · high la surface de paramètres de la passerelle - le mappage fournisseur ci-dessus s'applique |
Modèle
| Modalités | texte + image + vidéo → texte |
|---|---|
| Paramètres | 1T au total · 32B actifs MoE |
| Licence | Modified-MIT |
- MoE de 1T avec 32B actifs, contexte de 256K, multimodal natif (encodeur MoonViT, entrée image et vidéo), modes instantané et réflexion, Agent Swarm jusqu'à 100 sous-agents
- quantification INT4 native
Un prompt, mesuré via la passerelle
Kimi K2.5 réussi · 3 sentences
Enabling reasoning causes the model to perform extended internal deliberation, generating substantially more tokens per query than standard responses. Each reasoning chain consumes compute credits equivalent to multiple regular completions, and user query volume remained constant while per-query costs multiplied. The doubling reflects usage of a more expensive capability tier, not an operational error or billing anomaly.
sortie 67 tok latence 1.9 s
Suivi de l'instruction (exactement trois phrases - comptables), adaptation à l'audience (registre CFO), et l'écart de facturation lié à la réflexion cachée que les compteurs de tokens ci-dessous révèlent.
Kimi K2.5 réussi · 8/8 cases
The bug has two causes: the loop starts at index 1 and `cur` counts *additional* matching elements rather than the run length itself, so a single element run returns 0 instead of 1, and runs ending at the final element aren't properly captured because `best` is only updated inside the loop when elements match—meaning if the last run is just one element or if `cur` was never updated for the final position, the correct value gets lost. To fix this, initialize `best` and `cur` to 1 (since every run has at least one element), start the loop at 1, keep the same logic for incrementing `cur` when elements match and resetting otherwise, and update `best` after both branches or at the end to ensure the last run is considered. […]
sortie 250 tok latence 5.0 s
Si le correctif est réellement juste (exécutable), la densité de l'explication, et l'efficacité en tokens sur une tâche bornée.
Kimi K2.5 réussi · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "Q3", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null } ```
sortie 51 tok latence 1.6 s
Respect du schéma (aucun champ inventé), pression d'hallucination (guidance est explicitement retenue), et différences de chemin pour la sortie structurée.
Kimi K2.5 réussi · 113 words, 0 banned, 1 question
**Announcing Prompt Cache: One Store, Every Provider** Stop rewriting the same prompts for different AI platforms. Our new API gateway feature stores your prompts in a unified cache, making them instantly available across OpenAI, Anthropic, Google, and more. Switch providers without touching your prompt library. Compare outputs side-by-side using identical inputs. Your team maintains one source of truth while gaining the flexibility to route requests wherever performance or pricing demands. Version history tracks every edit. Access controls keep sensitive prompts secure. And with sub-10ms retrieval times, latency won't slow you down. Why maintain separate prompt libraries when one intelligent cache does it all? Prompt Cache is available today for Enterprise and Scale plans.
sortie 141 tok latence 3.3 s
Respect des contraintes (budget de mots, liste de mots interdits, l'unique question), empreinte stylistique, et contrôle de la longueur.
Utilisez Kimi K2.5 en 30 secondes
Compatible OpenAI : changez la base_url, gardez votre SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="kimi-k2.5",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "kimi-k2.5",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k2.5",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "kimi-k2.5",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("kimi-k2.5")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));À propos de Kimi K2.5
- Sa conception Mixture-of-Experts totalise 1T de paramètres avec 32B activés (384 experts, huit routés par token plus un partagé), ajoute l'encodeur visuel MoonViT de 400M de paramètres et prend en charge un contexte de 256K.
- Par rapport à Kimi K2, il introduit la compréhension vision-langage, la génération de code à partir de spécifications visuelles et Agent Swarm, passant de l'exécution mono-agent à un fonctionnement coordonné en essaim, avec des modes réflexion et instantané ; le billet de lancement de Moonshot décrit des essaims allant jusqu'à 100 sous-agents travaillant sur jusqu'à 1 500 appels d'outils.
- Moonshot nomme les charges de travail visées : génération et conversion de documents, création de diapositives, formules et analyses de tableurs, construction de sites web à partir de maquettes visuelles, et recherche approfondie avec synthèse de rapport.
- Les modes sont un paramètre et non un identifiant de modèle distinct : la réflexion est activée par défaut et le mode instantané correspond à la réflexion désactivée, le raisonnement étant renvoyé dans reasoning_content et décompté de max_tokens.
- Contrairement aux modèles de codage ultérieurs de Moonshot, il ne reporte pas le raisonnement d'un tour à l'autre : la conservation de la réflexion n'est pas prise en charge ici.
- L'appel de fonctions, les préremplissages en mode partiel, les réponses JSON et JSON-schema et la mise en cache automatique des prompts sont tous disponibles, et Moonshot livre une quantification INT4 native.
- Les poids sont diffusés sous une licence MIT modifiée dont le seul ajout est une obligation d'attribution pour les déploiements commerciaux de très grande taille.
- Synthorai rend Kimi K2.5 appelable via sa surface d'API compatible OpenAI.
FAQ
Peut-on essayer l'API Kimi K2.5 gratuitement ?
Oui : les nouveaux comptes reçoivent 10 appels d'essai et jusqu'à $1 de crédit gratuit, sans carte bancaire. À $0.574/M de tokens en entrée, ce crédit couvre à lui seul environ 217 requêtes de ~8K tokens sur Kimi K2.5.
Quels sont les points forts de Kimi K2.5 ?
Compréhension vision-langage et code depuis des specs visuelles ; agent swarm pour un fonctionnement multi-agent coordonné ; MoE de 1T de paramètres sous licence Modified MIT. Voir la section À propos pour le tableau complet, tiré des notes de version officielles du fournisseur.
Combien coûte Kimi K2.5 ?
Sur Synthorai, Kimi K2.5 coûte $0.574 par million de tokens en entrée et $3.011 par million de tokens en sortie, soit le prix catalogue du fournisseur, sans majoration de plateforme. Les tokens d'entrée en cache sont facturés $0.115/M.
Kimi K2.5 prend-il en charge la mise en cache des prompts ?
Oui, automatiquement : les prompts servis par Moonshot sont mis en cache sans modification de code. Les tokens d'entrée en cache sont facturés $0.115/M contre $0.574/M hors cache. Guide de mise en cache des prompts →
Comment obtenir l'accès à Kimi K2.5 ?
Pointez votre SDK OpenAI existant vers base_url="https://synthorai.io/v1", définissez model="kimi-k2.5", et c'est tout. Une seule clé API couvre tous les modèles de la passerelle.
Kimi K2.5 est-il open source ?
Oui : les poids sont publiés sous Modified-MIT (licence) (dépôt officiel lié dans la section À propos). Ou passez-vous des GPU : la version hébergée ici est au paiement à l'usage, sans infrastructure à exploiter. Exécuter des modèles à poids ouverts →
Modèles associés
Comparer
Chaque valeur de cette page est transcrite de la documentation du fournisseur, liée ci-dessus, et porte la date de sa vérification. Les prix sont comparés à l'échelle du catalogue ; les valeurs de spécification que les fournisseurs définissent différemment sont présentées avec la différence indiquée plutôt que mises en graphique. Rien ici n'est mesuré par nous, et rien n'est noté.