Kimi K2.7 Code est le modèle agentique de Moonshot AI axé sur le codage, construit sur Kimi K2.6, réglé pour l'ingénierie logicielle réelle et décrit par Moonshot comme son modèle de codage dédié, suivant les instructions de façon plus fiable en contexte long et menant à bien les tâches de codage avec de meilleurs taux de réussite.
- Entrée
- texte image vidéo $0.95/M
- Sortie
- texte $4/M
- Lecture de cache
- $0.19/M
- Contexte
- 256K
- vs GPT-4o
- ~81% moins cher
Benchmarks
Chiffres publiés par les fournisseurs : Alibaba (Qwen) Moonshot OpenAI 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 |
|---|---|
| Sortie max (spéc. fournisseur) | 32 768 |
Mise en cache
| Mode | automatique |
|---|
Raisonnement
| Paramètre du fournisseur | thinking.type + thinking.keep |
|---|---|
| Valeurs acceptées | type accepts only enabled; keep accepts only all |
| Valeur par défaut | réflexion activée avec Preserved Thinking activé appliquée si la requête ne précise rien |
| Désactivable | Non |
| Comportement du raisonnement | Passer type disabled renvoie une erreur ; comme Preserved Thinking est imposé côté serveur, le reasoning_content de chaque message assistant historique doit être renvoyé tel quel. |
| 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 |
- Modèle agentique axé sur le code, construit sur K2.6: MoE de 1T avec 32B actifs, contexte de 256K
- réflexion toujours active avec raisonnement préservé d'un tour à l'autre
- environ 30 % de tokens de réflexion en moins par rapport à K2.6
Un prompt, mesuré via la passerelle
Kimi K2.7 Code réussi · 3 sentences
Enabling reasoning mode causes the model to generate an internal chain-of-thought before producing each answer, and that hidden reasoning text is billed like any other output. Those extra reasoning tokens typically add up to much more than the final response itself, so every API call now costs significantly more than before. Because our overall usage volume did not change, the doubled bill reflects that each query consumes roughly twice as many billable tokens.
sortie 259 tok (+174 réflexion) latence 5.4 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.7 Code réussi · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The bug is that the function counts *transitions* between equal neighbors instead of counting the items themselves, so a single-element list never enters the loop and returns `0` instead of `1`. Likewise, resetting `cur` to `0` on a mismatch forgets the current item that starts a new run, which causes runs that end at the last index to be undercounted. Initializing both `best` and `cur` to `1` and resetting `cur` to `1` fixes both issues.
sortie 410 tok (+222 réflexion) latence 9.4 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.7 Code réussi · 5/5 fields, guidance "withheld pending the Q4 close"
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "withheld pending the Q4 close" } ```
sortie 721 tok (+663 réflexion) latence 13.2 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.7 Code réussi · 120 words, 0 banned, 1 question
We're introducing Prompt Cache for our API Gateway, a new capability that stores prompt responses across multiple AI providers. By caching replies, you reduce redundant calls, lower latency, and cut costs without changing how you build. Teams using several model providers can now reuse identical prompt results instantly, keeping traffic consistent and budgets predictable. Responses are keyed by provider, model, and exact prompt, so you always get the right result. Configure TTL, hit thresholds, and eviction rules from a single dashboard. It fits into your existing routing and requires no code changes. Setup takes minutes and works with your current endpoints. Want to see how much latency and spend you can trim? Check the docs to enable Prompt Cache today.
sortie 2375 tok (+2235 réflexion) latence 38.6 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.7 Code 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.7-code",
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.7-code",
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.7-code",
"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.7-code",
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.7-code")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));À propos de Kimi K2.7 Code
- Il conserve l'architecture Mixture-of-Experts de 1T de paramètres avec 32B activés par token (384 experts, huit par token plus un partagé) et un contexte de 256K, accepte l'entrée d'images en plus du texte, et fonctionne toujours en mode réflexion avec le contenu de raisonnement conservé d'un tour à l'autre.
- Le mode sans réflexion n'est pas simplement déconseillé, il est rejeté : la documentation indique que le modèle ne le prend pas en charge et que désactiver la réflexion renvoie une erreur, la conservation de la réflexion étant imposée côté serveur.
- Le raisonnement arrive dans reasoning_content avant la réponse, et le guide est explicite : vous devez renvoyer ce champ avec le message assistant sur les tours d'appel d'outils, sans quoi la requête échoue, ce qui constitue l'erreur d'intégration la plus fréquente avec ce modèle.
- Officiellement, il renforce l'exécution de bout en bout des tâches sur des workflows d'ingénierie logicielle complexes tout en consommant environ 30 % de tokens de réflexion en moins que K2.6, et prend en charge l'usage agentique d'outils via l'écosystème MCP avec une réflexion entrelacée sur des appels d'outils multi-étapes.
- Moonshot conseille de laisser une marge généreuse sur max_tokens, car le raisonnement la consomme.
- Les poids sont ouverts sous une licence MIT modifiée.
- Accédez à Kimi K2.7 Code sur Synthorai via l'endpoint compatible OpenAI.
FAQ
Peut-on essayer l'API Kimi K2.7 Code gratuitement ?
Oui : les nouveaux comptes reçoivent 10 appels d'essai et jusqu'à $1 de crédit gratuit, sans carte bancaire. À $0.95/M de tokens en entrée, ce crédit couvre à lui seul environ 131 requêtes de ~8K tokens sur Kimi K2.7 Code.
Quels sont les points forts de Kimi K2.7 Code ?
Environ 30 % de tokens de réflexion en moins ; raisonnement préservé au fil des conversations multi-tours ; réglé pour l'ingénierie logicielle du monde réel. Voir la section À propos pour le tableau complet, tiré des notes de version officielles du fournisseur.
Combien coûte Kimi K2.7 Code ?
Sur Synthorai, Kimi K2.7 Code coûte $0.95 par million de tokens en entrée et $4 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.19/M.
Kimi K2.7 Code 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.19/M contre $0.95/M hors cache. Guide de mise en cache des prompts →
Comment obtenir l'accès à Kimi K2.7 Code ?
Pointez votre SDK OpenAI existant vers base_url="https://synthorai.io/v1", définissez model="kimi-k2.7-code", et c'est tout. Une seule clé API couvre tous les modèles de la passerelle.
Kimi K2.7 Code est-il open source ?
Oui : les poids sont publiés sous Modified-MIT (licence). 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é.