What is Kimi-K2.7-Code designed for?

Kimi-K2.7-Code est un grand modèle de langage spécialisé dans le codage, optimisé pour l’ingénierie logicielle axée sur les agents, la compréhension de code à l’échelle d’un dépôt et des processus de développement longs et à étapes multiples.

How does Kimi-K2.7-Code improve over Kimi-K2.6?

Selon Moonshot AI, K2.7-Code améliore les scores sur plusieurs évaluations de codage tout en réduisant d’environ 30% l’utilisation de jetons de raisonnement, rendant les tâches de codage de longue durée plus efficaces.

Can I use Kimi-K2.7-Code with existing OpenAI-compatible tools?

Oui. La plateforme Kimi Code expose des points de terminaison d’API compatibles avec OpenAI et Anthropic, permettant à de nombreux outils de codage existants de s’intégrer avec des modifications minimales.

What API model ID should developers use?

CometAPI recommande d’utiliser l’identifiant de modèle stable `kimi-for-coding`, qui est automatiquement associé à la dernière version backend du modèle de codage.

Is Kimi-K2.7-Code suitable for AI coding agents?

Oui. Le modèle est spécialement ajusté pour des flux de travail de type agent impliquant l’édition de fichiers, l’exécution de commandes, la gestion de longs contextes et l’accomplissement itératif de tâches.

Does Kimi-K2.7-Code support self-hosting?

Oui. Moonshot AI a publié Kimi-K2.7-Code en tant que modèle open-weight sous une Modified MIT License, permettant le déploiement et l’expérimentation par la communauté.

How does Kimi-K2.7-Code perform on coding benchmarks?

Les résultats rapportés par le fournisseur montrent des améliorations de +21.8% sur Kimi Code Bench v2, de +11.0% sur Program Bench et de +31.5% sur MLS Bench Lite par rapport à K2.6.

When should I choose Kimi-K2.7-Code instead of a general-purpose model?

Kimi-K2.7-Code est un excellent choix lorsque votre charge de travail implique du codage à l’échelle d’un dépôt, des agents logiciels d’IA, une intégration IDE ou des tâches d’ingénierie multi-fichiers où des capacités de codage spécialisées importent davantage qu’une conversation généraliste.

API Kimi K2.7 Code Abordable | text-to-text

Spécifications techniques de Kimi K2.7 Code

Spécification	Détails
Nom du modèle	Kimi K2.7 Code
ID du modèle	kimi-k2.7-code
Fournisseur	Moonshot AI
Famille de modèles	Kimi K2
Type de modèle	Grand modèle de langage axé sur le codage
Architecture	Mélange d’experts (MoE)
Paramètres totaux	1 000 milliards (selon le fournisseur)
Paramètres actifs	32 milliards (selon le fournisseur)
Types d’entrée	Texte
Types de sortie	Texte
Fenêtre de contexte	256K jetons
Modes de raisonnement	Raisonnement multi-étapes pour les flux de travail de codage
Prise en charge des outils	Flux de travail d’agents pris en charge ; spécifications complètes non divulguées publiquement
Appel de fonctions	Non divulgué publiquement
Compatibilité API	Disponible via CometAPI

Qu’est-ce que Kimi K2.7 Code ?

Kimi K2.7 Code est un modèle de langage spécialisé dans le codage, développé par Moonshot AI au sein de la famille Kimi K2. Le modèle vise des cas d’usage d’ingénierie logicielle professionnelle qui exigent une génération de code précise, une compréhension de longs contextes et une résolution de problèmes itérative.

La philosophie de conception de K2.7 Code met l’accent sur la capacité à travailler sur des projets complets plutôt que des extraits isolés. En prenant en charge des contextes extrêmement larges, le modèle peut analyser simultanément les décisions d’architecture, les détails d’implémentation, les suites de tests et la documentation.

Au sein de l’écosystème Moonshot AI, Kimi K2.7 Code occupe le rôle d’un modèle de codage de haute capacité destiné à la productivité des développeurs, aux systèmes d’agents et à l’automatisation de l’ingénierie d’entreprise.

Principales fonctionnalités de Kimi K2.7 Code

1. Compréhension de dépôts à contexte long

La fenêtre de contexte de 256K jetons permet aux développeurs de fournir de grands dépôts, de la documentation d’API, des notes d’architecture et des documents d’appui dans une seule session.

2. Optimisation centrée sur le codage

Contrairement aux modèles conversationnels généralistes, K2.7 Code privilégie les tâches d’ingénierie logicielle, notamment l’implémentation, le débogage, le refactoring et l’explication.

3. Efficacité du Mixture-of-Experts

Moonshot AI indique que le modèle n’active qu’un sous-ensemble de ses paramètres totaux lors de l’inférence, équilibrant capacités et efficacité computationnelle.

4. Prise en charge des flux d’agents

K2.7 Code est conçu pour prendre en charge des flux de travail de codage itératifs où la planification, l’exécution, la validation et la révision s’effectuent en plusieurs étapes.

5. Raisonnement multi-fichiers

Les développeurs peuvent analyser les dépendances et interactions entre des composants répartis dans de grands projets.

Performances de Kimi K2.7 Code aux benchmarks

Au moment de la rédaction, la couverture par des benchmarks indépendants pour Kimi K2.7 Code reste limitée.

Moonshot AI a publié les améliorations suivantes par rapport aux versions Kimi précédentes :

Benchmark	Amélioration rapportée
Kimi Code Bench v2	+21,8 %
Program Bench	+11,0 %
MLS Bench Lite	+31,5 %

Ces chiffres proviennent des communications du fournisseur et doivent être interprétés comme des résultats rapportés par le fournisseur plutôt que des classements vérifiés de manière indépendante.

Signification des benchmarks

Les améliorations rapportées suggèrent que Kimi K2.7 Code met l’accent sur des résultats de codage pratiques plutôt que sur des performances conversationnelles générales. Les gains dans les évaluations orientées codage peuvent se traduire par une meilleure compréhension des dépôts, une précision d’implémentation accrue et une productivité améliorée en ingénierie logicielle.

Kimi K2.7 Code par rapport à des modèles similaires

Modèle	Fenêtre de contexte	Focalisation principale	Atouts	Meilleurs cas d’usage
Kimi K2.7 Code	256K	Codage	Flux d’ingénierie à long contexte	Agents de codage et analyse de dépôts
Claude Code Models	Grande	Codage et raisonnement	Suivi d’instructions robuste	Assistants de codage pour l’entreprise
GPT Coding Models	Grande	Général + codage	Large écosystème de support	Applications de production et intégrations
DeepSeek Coding Models	Grande	Efficacité en codage	Déploiements ouverts compétitifs	Équipes d’ingénierie soucieuses des coûts

Résumé de la comparaison

Kimi K2.7 Code se différencie par sa combinaison de traitement de très longs contextes et de spécialisation en codage. Les organisations priorisant une compréhension à l’échelle du dépôt et des flux de travail d’agents peuvent tirer parti de son architecture, tandis que les équipes recherchant des capacités multimodales plus larges peuvent préférer des alternatives plus généralistes.

Limitations connues

Les limites maximales de jetons en sortie n’ont pas été divulguées publiquement.
La validation indépendante par des benchmarks reste limitée.
La documentation publique ne précise pas le comportement d’appel de fonctions.
Les capacités vision, audio et vidéo n’ont pas été documentées.
Les caractéristiques de performance hors tâches de codage sont moins établies.
Les directives de déploiement en entreprise restent relativement limitées par rapport à des écosystèmes plus matures.

Comment utiliser l’API Kimi K2.7 Code sur CometAPI

Étape 1 : Obtenez votre clé API

Créez ou connectez-vous à votre compte CometAPI et générez une clé API. Vérifiez que l’identifiant de modèle pris en charge le plus récent est :

kimi-k2.7-code

Consultez la documentation actuelle de l’endpoint avant le déploiement pour confirmer les exigences de compatibilité.

Étape 2 : Testez le modèle

Commencez avec des prompts de développement réalistes reflétant votre environnement de production.

Exemples de scénarios :

Refactoriser un module hérité.
Examiner une pull request.
Générer des tests unitaires.
Expliquer l’architecture du dépôt.
Implémenter des fonctionnalités à partir de spécifications.

Tester sur des charges de travail représentatives permet de mieux comprendre le comportement du modèle que des exemples synthétiques.

Étape 3 : Intégrez en production

Lorsque votre environnement le permet, utilisez des schémas de SDK compatibles OpenAI pour accélérer l’adoption.

Recommandations pour la production :

Activer les réponses en streaming pour améliorer l’expérience utilisateur.
Implémenter des réessais avec backoff exponentiel.
Maintenir la journalisation des requêtes et des réponses.
Valider le code généré avant exécution.
Introduire une relecture humaine pour les flux de travail critiques.
Surveiller les métriques de qualité à l’aide de tâches d’ingénierie représentatives.

Kimi K2.7 Code est particulièrement bien adapté aux systèmes de développement à base d’agents où la planification, l’implémentation, la vérification et l’itération se déroulent en continu tout au long du cycle de vie logiciel.

Tarification pour Kimi K2.7 Code

Découvrez des tarifs compétitifs pour Kimi K2.7 Code, conçus pour s'adapter à différents budgets et besoins d'utilisation. Nos formules flexibles garantissent que vous ne payez que ce que vous utilisez, ce qui facilite l'adaptation à mesure que vos besoins évoluent. Découvrez comment Kimi K2.7 Code peut améliorer vos projets tout en maîtrisant les coûts.

Prix de Comet (USD / M Tokens)	Prix officiel (USD / M Tokens)	Remise
Entrée:$0.76/M Sortie:$3.19998/M	Entrée:$0.95/M Sortie:$3.999975/M	-20%

Exemple de code et API pour Kimi K2.7 Code

Accédez à des exemples de code complets et aux ressources API pour Kimi K2.7 Code afin de simplifier votre processus d'intégration. Notre documentation détaillée fournit des instructions étape par étape pour vous aider à exploiter tout le potentiel de Kimi K2.7 Code dans vos projets.

Python
JavaScript
Curl

import base64
import json
import os
import subprocess
import tempfile
from pathlib import Path

from openai import OpenAI

# Get your CometAPI key from https://www.cometapi.com/console/token
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com/v1"
MODEL = "kimi-k2.7-code"
VIDEO_PATH = os.environ.get("KIMI_VIDEO_PATH") or str(Path.home() / "Downloads" / "test_video.mp4")

client = OpenAI(base_url=BASE_URL, api_key=COMETAPI_KEY)

tools = [
    {
        "type": "function",
        "function": {
            "name": "watch_video_clip",
            "description": "Watch a video file or a sub-clip of it. If start_time and end_time are not provided, the entire video will be returned.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "The path to the video file to watch",
                    },
                    "start_time": {
                        "type": "number",
                        "description": "The start time of the clip in seconds (optional, defaults to 0)",
                    },
                    "end_time": {
                        "type": "number",
                        "description": "The end time of the clip in seconds (optional, defaults to end of video)",
                    },
                },
                "required": ["path"],
            },
        },
    }
]

def video_block(path):
    suffix = Path(path).suffix.lstrip(".") or "mp4"
    with open(path, "rb") as video_file:
        video_base64 = base64.b64encode(video_file.read()).decode("utf-8")
    return {"type": "video_url", "video_url": {"url": f"data:video/{suffix};base64,{video_base64}"}}

def watch_video_clip(path, start_time=None, end_time=None):
    video_path = Path(path).expanduser()
    if not video_path.exists():
        raise FileNotFoundError(f"Video file not found: {video_path}")

    if start_time is None and end_time is None:
        return [
            video_block(video_path),
            {"type": "text", "text": f"Full video: {video_path.name}"},
        ]

    probe = subprocess.run(
        ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", str(video_path)],
        capture_output=True,
        text=True,
        check=True,
    )
    duration = float(json.loads(probe.stdout)["format"]["duration"])
    start_time = start_time or 0
    end_time = end_time or duration
    clip_duration = end_time - start_time

    with tempfile.NamedTemporaryFile(suffix=video_path.suffix or ".mp4", delete=False) as tmp:
        tmp_path = tmp.name

    try:
        subprocess.run(
            [
                "ffmpeg",
                "-y",
                "-ss",
                str(start_time),
                "-i",
                str(video_path),
                "-t",
                str(clip_duration),
                "-c:v",
                "libx264",
                "-c:a",
                "aac",
                "-preset",
                "fast",
                "-crf",
                "23",
                "-movflags",
                "+faststart",
                "-loglevel",
                "error",
                tmp_path,
            ],
            check=True,
        )
        return [
            video_block(tmp_path),
            {"type": "text", "text": f"Clip from {video_path.name}: {start_time}s - {end_time}s"},
        ]
    finally:
        os.unlink(tmp_path)

def agent_loop(user_message):
    messages = [
        {
            "role": "system",
            "content": "You are a video analysis assistant. Use watch_video_clip to examine specific portions of videos.",
        },
        {"role": "user", "content": user_message},
    ]

    while True:
        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=tools,
            tool_choice="auto",
        )
        message = response.choices[0].message
        messages.append(message.model_dump(exclude_none=True))

        if not message.tool_calls:
            return message.content or response.model_dump_json(indent=2)

        for tool_call in message.tool_calls:
            if tool_call.function.name != "watch_video_clip":
                continue
            args = json.loads(tool_call.function.arguments or "{}")
            messages.append(
                {
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": watch_video_clip(
                        args["path"],
                        start_time=args.get("start_time"),
                        end_time=args.get("end_time"),
                    ),
                }
            )

if __name__ == "__main__":
    if not Path(VIDEO_PATH).expanduser().exists():
        raise SystemExit(f"Set KIMI_VIDEO_PATH to a local video file before running this example: {VIDEO_PATH}")
    answer = agent_loop(f"Analyze what happens between seconds 8-13 in {VIDEO_PATH}")
    print(answer)

Python Code Example

import base64
import json
import os
import subprocess
import tempfile
from pathlib import Path

from openai import OpenAI

# Get your CometAPI key from https://www.cometapi.com/console/token
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com/v1"
MODEL = "kimi-k2.7-code"
VIDEO_PATH = os.environ.get("KIMI_VIDEO_PATH") or str(Path.home() / "Downloads" / "test_video.mp4")

client = OpenAI(base_url=BASE_URL, api_key=COMETAPI_KEY)

tools = [
    {
        "type": "function",
        "function": {
            "name": "watch_video_clip",
            "description": "Watch a video file or a sub-clip of it. If start_time and end_time are not provided, the entire video will be returned.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "The path to the video file to watch",
                    },
                    "start_time": {
                        "type": "number",
                        "description": "The start time of the clip in seconds (optional, defaults to 0)",
                    },
                    "end_time": {
                        "type": "number",
                        "description": "The end time of the clip in seconds (optional, defaults to end of video)",
                    },
                },
                "required": ["path"],
            },
        },
    }
]


def video_block(path):
    suffix = Path(path).suffix.lstrip(".") or "mp4"
    with open(path, "rb") as video_file:
        video_base64 = base64.b64encode(video_file.read()).decode("utf-8")
    return {"type": "video_url", "video_url": {"url": f"data:video/{suffix};base64,{video_base64}"}}


def watch_video_clip(path, start_time=None, end_time=None):
    video_path = Path(path).expanduser()
    if not video_path.exists():
        raise FileNotFoundError(f"Video file not found: {video_path}")

    if start_time is None and end_time is None:
        return [
            video_block(video_path),
            {"type": "text", "text": f"Full video: {video_path.name}"},
        ]

    probe = subprocess.run(
        ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", str(video_path)],
        capture_output=True,
        text=True,
        check=True,
    )
    duration = float(json.loads(probe.stdout)["format"]["duration"])
    start_time = start_time or 0
    end_time = end_time or duration
    clip_duration = end_time - start_time

    with tempfile.NamedTemporaryFile(suffix=video_path.suffix or ".mp4", delete=False) as tmp:
        tmp_path = tmp.name

    try:
        subprocess.run(
            [
                "ffmpeg",
                "-y",
                "-ss",
                str(start_time),
                "-i",
                str(video_path),
                "-t",
                str(clip_duration),
                "-c:v",
                "libx264",
                "-c:a",
                "aac",
                "-preset",
                "fast",
                "-crf",
                "23",
                "-movflags",
                "+faststart",
                "-loglevel",
                "error",
                tmp_path,
            ],
            check=True,
        )
        return [
            video_block(tmp_path),
            {"type": "text", "text": f"Clip from {video_path.name}: {start_time}s - {end_time}s"},
        ]
    finally:
        os.unlink(tmp_path)


def agent_loop(user_message):
    messages = [
        {
            "role": "system",
            "content": "You are a video analysis assistant. Use watch_video_clip to examine specific portions of videos.",
        },
        {"role": "user", "content": user_message},
    ]

    while True:
        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=tools,
            tool_choice="auto",
        )
        message = response.choices[0].message
        messages.append(message.model_dump(exclude_none=True))

        if not message.tool_calls:
            return message.content or response.model_dump_json(indent=2)

        for tool_call in message.tool_calls:
            if tool_call.function.name != "watch_video_clip":
                continue
            args = json.loads(tool_call.function.arguments or "{}")
            messages.append(
                {
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": watch_video_clip(
                        args["path"],
                        start_time=args.get("start_time"),
                        end_time=args.get("end_time"),
                    ),
                }
            )


if __name__ == "__main__":
    if not Path(VIDEO_PATH).expanduser().exists():
        raise SystemExit(f"Set KIMI_VIDEO_PATH to a local video file before running this example: {VIDEO_PATH}")
    answer = agent_loop(f"Analyze what happens between seconds 8-13 in {VIDEO_PATH}")
    print(answer)

JavaScript Code Example

import { execFileSync } from "node:child_process";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import OpenAI from "openai";

// Get your CometAPI key from https://www.cometapi.com/console/token
const COMETAPI_KEY = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const BASE_URL = "https://api.cometapi.com/v1";
const MODEL = "kimi-k2.7-code";
const VIDEO_PATH = process.env.KIMI_VIDEO_PATH || path.join(os.homedir(), "Downloads", "test_video.mp4");

const client = new OpenAI({
  apiKey: COMETAPI_KEY,
  baseURL: BASE_URL,
});

const tools = [
  {
    type: "function",
    function: {
      name: "watch_video_clip",
      description:
        "Watch a video file or a sub-clip of it. If start_time and end_time are not provided, the entire video will be returned.",
      parameters: {
        type: "object",
        properties: {
          path: {
            type: "string",
            description: "The path to the video file to watch",
          },
          start_time: {
            type: "number",
            description: "The start time of the clip in seconds (optional, defaults to 0)",
          },
          end_time: {
            type: "number",
            description: "The end time of the clip in seconds (optional, defaults to end of video)",
          },
        },
        required: ["path"],
      },
    },
  },
];

function videoBlock(videoPath) {
  const suffix = path.extname(videoPath).slice(1) || "mp4";
  const videoBase64 = fs.readFileSync(videoPath).toString("base64");
  return { type: "video_url", video_url: { url: `data:video/${suffix};base64,${videoBase64}` } };
}

function watchVideoClip(videoPath, startTime = null, endTime = null) {
  const resolvedPath = path.resolve(videoPath.replace(/^~(?=$|\/|\\)/, os.homedir()));
  if (!fs.existsSync(resolvedPath)) {
    throw new Error(`Video file not found: ${resolvedPath}`);
  }

  if (startTime === null && endTime === null) {
    return [videoBlock(resolvedPath), { type: "text", text: `Full video: ${path.basename(resolvedPath)}` }];
  }

  const probe = execFileSync("ffprobe", ["-v", "quiet", "-print_format", "json", "-show_format", resolvedPath], {
    encoding: "utf8",
  });
  const duration = Number(JSON.parse(probe).format.duration);
  const start = startTime ?? 0;
  const end = endTime ?? duration;
  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "kimi-video-"));
  const tempPath = path.join(tempDir, `clip${path.extname(resolvedPath) || ".mp4"}`);

  try {
    execFileSync("ffmpeg", [
      "-y",
      "-ss",
      String(start),
      "-i",
      resolvedPath,
      "-t",
      String(end - start),
      "-c:v",
      "libx264",
      "-c:a",
      "aac",
      "-preset",
      "fast",
      "-crf",
      "23",
      "-movflags",
      "+faststart",
      "-loglevel",
      "error",
      tempPath,
    ]);

    return [
      videoBlock(tempPath),
      { type: "text", text: `Clip from ${path.basename(resolvedPath)}: ${start}s - ${end}s` },
    ];
  } finally {
    fs.rmSync(tempDir, { recursive: true, force: true });
  }
}

async function agentLoop(userMessage) {
  const messages = [
    {
      role: "system",
      content: "You are a video analysis assistant. Use watch_video_clip to examine specific portions of videos.",
    },
    { role: "user", content: userMessage },
  ];

  while (true) {
    const response = await client.chat.completions.create({
      model: MODEL,
      messages,
      tools,
      tool_choice: "auto",
    });
    const message = response.choices[0].message;
    messages.push(message);

    if (!message.tool_calls?.length) {
      return message.content || JSON.stringify(response, null, 2);
    }

    for (const toolCall of message.tool_calls) {
      if (toolCall.function.name !== "watch_video_clip") continue;
      const args = JSON.parse(toolCall.function.arguments || "{}");
      messages.push({
        role: "tool",
        tool_call_id: toolCall.id,
        content: watchVideoClip(args.path, args.start_time, args.end_time),
      });
    }
  }
}

if (!fs.existsSync(path.resolve(VIDEO_PATH.replace(/^~(?=$|\/|\\)/, os.homedir())))) {
  throw new Error(`Set KIMI_VIDEO_PATH to a local video file before running this example: ${VIDEO_PATH}`);
}

console.log(await agentLoop(`Analyze what happens between seconds 8-13 in ${VIDEO_PATH}`));

Curl Code Example

#!/bin/bash

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"
# Optionally set a local video path: export KIMI_VIDEO_PATH="$HOME/Downloads/test_video.mp4"

VIDEO_PATH="${KIMI_VIDEO_PATH:-$HOME/Downloads/test_video.mp4}"

curl -s https://api.cometapi.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -d "{
    \"model\": \"kimi-k2.7-code\",
    \"messages\": [
      {
        \"role\": \"system\",
        \"content\": \"You are a video analysis assistant. Use watch_video_clip to examine specific portions of videos.\"
      },
      {
        \"role\": \"user\",
        \"content\": \"Analyze what happens between seconds 8-13 in ${VIDEO_PATH}\"
      }
    ],
    \"tools\": [
      {
        \"type\": \"function\",
        \"function\": {
          \"name\": \"watch_video_clip\",
          \"description\": \"Watch a video file or a sub-clip of it. If start_time and end_time are not provided, the entire video will be returned.\",
          \"parameters\": {
            \"type\": \"object\",
            \"properties\": {
              \"path\": {
                \"type\": \"string\",
                \"description\": \"The path to the video file to watch\"
              },
              \"start_time\": {
                \"type\": \"number\",
                \"description\": \"The start time of the clip in seconds (optional, defaults to 0)\"
              },
              \"end_time\": {
                \"type\": \"number\",
                \"description\": \"The end time of the clip in seconds (optional, defaults to end of video)\"
              }
            },
            \"required\": [\"path\"]
          }
        }
      }
    ],
    \"tool_choice\": \"auto\"
  }"

Versions de Kimi K2.7 Code

La raison pour laquelle Kimi K2.7 Code dispose de plusieurs instantanés peut inclure des facteurs potentiels tels que des variations de sortie après des mises à jour nécessitant des instantanés plus anciens pour la cohérence, offrant aux développeurs une période de transition pour l'adaptation et la migration, et différents instantanés correspondant à des points de terminaison globaux ou régionaux pour optimiser l'expérience utilisateur. Pour les différences détaillées entre les versions, veuillez consulter la documentation officielle.

version
kimi-k2.7-code