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

Kimi-K2.7-Code es un modelo de lenguaje grande especializado en programación, optimizado para la ingeniería de software basada en agentes, la comprensión del código a escala de repositorio y los flujos de trabajo de desarrollo largos y de múltiples pasos.

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

Según Moonshot AI, K2.7-Code mejora las puntuaciones en varios benchmarks de programación mientras reduce el uso de tokens de razonamiento en alrededor de un 30%, lo que hace más eficientes las tareas de programación de larga duración.

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

Sí. La plataforma Kimi Code expone endpoints de API compatibles con OpenAI y Anthropic, lo que permite que muchas herramientas de programación existentes se integren con cambios mínimos.

What API model ID should developers use?

CometAPIrecommends recomienda usar el identificador de modelo estable `kimi-for-coding`, que se asigna automáticamente a la última versión del modelo de programación en el backend.

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

Sí. El modelo está específicamente ajustado para flujos de trabajo de estilo agente que implican edición de archivos, ejecución de comandos, manejo de contextos largos y finalización iterativa de tareas.

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

Sí. Moonshot AI ha publicado Kimi-K2.7-Code como un modelo de pesos abiertos bajo una Licencia MIT Modificada, lo que permite el despliegue y la experimentación por parte de la comunidad.

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

Los resultados reportados por el proveedor muestran mejoras de +21.8% en Kimi Code Bench v2, +11.0% en Program Bench y +31.5% en MLS Bench Lite en comparación con K2.6.

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

Kimi-K2.7-Code es una opción sólida cuando la carga de trabajo implica programación a escala de repositorio, agentes de software de IA, integración con IDE o tareas de ingeniería con múltiples archivos, donde las capacidades de programación especializadas importan más que una conversación amplia de propósito general.

API de Kimi K2.7 Code Asequible | text-to-text

Especificaciones técnicas de Kimi K2.7 Code

Especificación	Detalles
Nombre del modelo	Kimi K2.7 Code
ID del modelo	kimi-k2.7-code
Proveedor	Moonshot AI
Familia del modelo	Kimi K2
Tipo de modelo	Modelo de lenguaje grande centrado en programación
Arquitectura	Mezcla de expertos (MoE)
Parámetros totales	1 billón (según el proveedor)
Parámetros activos	32 mil millones (según el proveedor)
Tipos de entrada	Texto
Tipos de salida	Texto
Ventana de contexto	256K tokens
Modos de razonamiento	Razonamiento de múltiples pasos para flujos de trabajo de programación
Soporte de herramientas	Se admiten flujos de trabajo de agentes; las especificaciones completas no se han divulgado públicamente
Llamadas a funciones	No divulgado públicamente
Compatibilidad con API	Disponible a través de CometAPI

¿Qué es Kimi K2.7 Code?

Kimi K2.7 Code es un modelo de lenguaje especializado en programación desarrollado por Moonshot AI como parte de la familia Kimi K2. El modelo se dirige a casos de uso de ingeniería de software profesional que exigen generación de código precisa, comprensión de contextos largos y resolución iterativa de problemas.

La filosofía de diseño detrás de K2.7 Code se centra en permitir a los desarrolladores trabajar con proyectos completos en lugar de fragmentos aislados. Al admitir contextos extremadamente amplios, el modelo puede analizar simultáneamente decisiones de arquitectura, detalles de implementación, suites de pruebas y documentación.

Dentro del ecosistema de Moonshot AI, Kimi K2.7 Code ocupa el rol de un modelo de codificación de alta capacidad destinado a la productividad de los desarrolladores, sistemas de agentes y automatización de ingeniería empresarial.

Características principales de Kimi K2.7 Code

1. Comprensión de repositorios de largo contexto

La ventana de contexto de 256K tokens permite a los desarrolladores proporcionar repositorios grandes, documentación de API, notas de arquitectura y materiales de apoyo en una sola sesión.

2. Optimización centrada en la programación

A diferencia de los modelos conversacionales generales, K2.7 Code prioriza tareas de ingeniería de software, incluyendo implementación, depuración, refactorización y explicación.

3. Eficiencia de mezcla de expertos

Moonshot AI informa que el modelo activa solo un subconjunto de sus parámetros totales durante la inferencia, equilibrando capacidad y eficiencia computacional.

4. Soporte para flujos de trabajo de agentes

K2.7 Code está diseñado para admitir flujos de trabajo de programación iterativos donde la planificación, la ejecución, la validación y la revisión ocurren en múltiples pasos.

5. Razonamiento entre múltiples archivos

Los desarrolladores pueden analizar dependencias e interacciones entre componentes distribuidos en proyectos grandes.

Rendimiento en benchmarks de Kimi K2.7 Code

Al momento de redactar esto, la cobertura independiente de benchmarks para Kimi K2.7 Code sigue siendo limitada.

Moonshot AI ha publicado las siguientes mejoras con respecto a versiones anteriores de Kimi:

Benchmark	Mejora reportada
Kimi Code Bench v2	+21.8%
Program Bench	+11.0%
MLS Bench Lite	+31.5%

Estas cifras proceden de comunicaciones del proveedor y deben interpretarse como resultados reportados por el proveedor, no como clasificaciones verificadas de forma independiente.

Relevancia de los benchmarks

Las mejoras reportadas sugieren que Kimi K2.7 Code se centra en resultados prácticos de programación más que en el rendimiento conversacional general. Las ganancias en evaluaciones orientadas a la codificación pueden traducirse en una mejor comprensión de repositorios, mayor precisión de implementación y productividad en ingeniería de software.

Kimi K2.7 Code frente a modelos similares

Modelo	Ventana de contexto	Enfoque principal	Fortalezas	Mejores casos de uso
Kimi K2.7 Code	256K	Programación	Flujos de ingeniería con contexto extenso	Agentes de programación y análisis de repositorios
Claude Code Models	Amplia	Programación y razonamiento	Gran capacidad de seguimiento de instrucciones	Asistentes de programación para empresas
GPT Coding Models	Amplia	General + programación	Amplio soporte del ecosistema	Aplicaciones e integraciones en producción
DeepSeek Coding Models	Amplia	Eficiencia en programación	Despliegues abiertos competitivos	Equipos de ingeniería conscientes de los costos

Resumen de la comparación

Kimi K2.7 Code se diferencia por su combinación de procesamiento de contexto largo y especialización en programación. Las organizaciones que priorizan la comprensión a escala de repositorio y los flujos de trabajo con agentes pueden beneficiarse de su arquitectura, mientras que los equipos que buscan capacidades multimodales más amplias pueden preferir alternativas de propósito general.

Limitaciones conocidas

Los límites máximos de tokens de salida no se han divulgado públicamente.
La validación independiente de benchmarks sigue siendo limitada.
La documentación pública no especifica el comportamiento de llamadas a funciones.
No se han documentado capacidades de visión, audio y vídeo.
Las características de rendimiento fuera de tareas de programación están menos establecidas.
La guía de despliegue empresarial sigue siendo relativamente limitada en comparación con ecosistemas más maduros.

Cómo usar la API de Kimi K2.7 Code en CometAPI

Paso 1: Obtén tu clave de API

Crea o inicia sesión en tu cuenta de CometAPI y genera una clave de API. Verifica que el identificador de modelo más reciente compatible sea:

kimi-k2.7-code

Revisa la documentación actual del endpoint antes del despliegue para confirmar los requisitos de compatibilidad.

Paso 2: Prueba el modelo

Empieza con indicaciones de desarrollo realistas que reflejen tu entorno de producción.

Los escenarios de ejemplo incluyen:

Refactorización de un módulo heredado.
Revisión de una pull request.
Generación de pruebas unitarias.
Explicación de la arquitectura del repositorio.
Implementación de funciones a partir de especificaciones.

Probar con cargas de trabajo representativas proporciona una comprensión más clara del comportamiento del modelo que los ejemplos sintéticos.

Paso 3: Integra en producción

Cuando tu entorno lo permita, utiliza patrones de SDK compatibles con OpenAI para acelerar la adopción.

Las recomendaciones para producción incluyen:

Habilita respuestas en streaming para mejorar la experiencia del usuario.
Implementa reintentos con espera exponencial.
Mantén el registro de solicitudes y respuestas.
Valida el código generado antes de la ejecución.
Introduce revisión humana para los flujos de trabajo críticos.
Supervisa métricas de calidad utilizando tareas de ingeniería representativas.

Kimi K2.7 Code es especialmente adecuado para sistemas de desarrollo basados en agentes en los que la planificación, la implementación, la verificación y la iteración se producen de forma continua a lo largo del ciclo de vida del software.

Precios para Kimi K2.7 Code

Explora precios competitivos para Kimi K2.7 Code, diseñado para adaptarse a diversos presupuestos y necesidades de uso. Nuestros planes flexibles garantizan que solo pagues por lo que uses, facilitando el escalado a medida que crecen tus requisitos. Descubre cómo Kimi K2.7 Code puede mejorar tus proyectos mientras mantienes los costos manejables.

Precio de Comet (USD / M Tokens)	Precio Oficial (USD / M Tokens)	Descuento
Entrada:$0.76/M Salida:$3.19998/M	Entrada:$0.95/M Salida:$3.999975/M	-20%

Código de ejemplo y API para Kimi K2.7 Code

Accede a código de muestra completo y recursos de API para Kimi K2.7 Code para agilizar tu proceso de integración. Nuestra documentación detallada proporciona orientación paso a paso, ayudándote a aprovechar todo el potencial de Kimi K2.7 Code en tus proyectos.

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\"
  }"

Versiones de Kimi K2.7 Code

La razón por la cual Kimi K2.7 Code tiene múltiples instantáneas puede incluir factores potenciales como variaciones en la salida tras actualizaciones que requieren instantáneas anteriores para mantener la coherencia, ofrecer a los desarrolladores un período de transición para adaptación y migración, y diferentes instantáneas que corresponden a endpoints globales o regionales para optimizar la experiencia del usuario. Para conocer las diferencias detalladas entre versiones, consulte la documentación oficial.

version
kimi-k2.7-code