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

Kimi-K2.7-Code ist ein auf Programmierung spezialisiertes großes Sprachmodell, das für agentenbasierte Softwareentwicklung, Codeverständnis auf Repository-Ebene und lange, mehrstufige Entwicklungs-Workflows optimiert ist.

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

Laut Moonshot AI verbessert K2.7-Code die Benchmark-Ergebnisse in mehreren Coding-Evaluierungen und reduziert zugleich die Nutzung von Reasoning-Token um etwa 30%, was lang laufende Coding-Aufgaben effizienter macht.

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

Ja. Die Kimi Code Plattform stellt OpenAI-kompatible und Anthropic-kompatible API-Endpunkte bereit, sodass viele bestehende Coding-Tools mit minimalen Änderungen integriert werden können.

What API model ID should developers use?

CometAPI empfiehlt, den stabilen Modellbezeichner `kimi-for-coding` zu verwenden, der automatisch auf die neueste Backend-Coding-Modellversion abbildet.

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

Ja. Das Modell ist speziell auf Agenten-Workflows abgestimmt, die Dateibearbeitung, Befehlsausführung, den Umgang mit langen Kontexten und iterative Aufgabenerledigung umfassen.

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

Ja. Moonshot AI hat Kimi-K2.7-Code als Open-Weight-Modell unter einer Modified MIT License veröffentlicht, wodurch Bereitstellung und Experimente durch die Community ermöglicht werden.

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

Vom Anbieter gemeldete Ergebnisse zeigen Verbesserungen von +21.8% auf dem Kimi Code Bench v2, +11.0% auf dem Program Bench und +31.5% auf dem MLS Bench Lite im Vergleich zu K2.6.

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

Kimi-K2.7-Code ist eine gute Wahl, wenn Ihre Arbeitslast Programmierung auf Repository-Ebene, KI-Software-Agenten, IDE-Integration oder Engineering-Aufgaben über mehrere Dateien umfasst, bei denen spezialisierte Coding-Fähigkeiten wichtiger sind als breit angelegte allgemeine Konversation.

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

Technische Spezifikationen von Kimi K2.7 Code

Spezifikation	Details
Modellname	Kimi K2.7 Code
Modell-ID	kimi-k2.7-code
Anbieter	Moonshot AI
Modellfamilie	Kimi K2
Modelltyp	Großes Sprachmodell mit Fokus auf Coding
Architektur	Mixture-of-Experts (MoE)
Gesamtparameter	1 Billion (vom Anbieter berichtet)
Aktive Parameter	32 Milliarden (vom Anbieter berichtet)
Eingabetypen	Text
Ausgabetypen	Text
Kontextfenster	256K Token
Reasoning-Modi	Mehrschritt-Schlussfolgern für Coding-Workflows
Tool-Unterstützung	Agent-Workflows werden unterstützt; vollständige Spezifikationen nicht öffentlich offengelegt
Funktionsaufrufe	Nicht öffentlich offengelegt
API-Kompatibilität	Verfügbar über CometAPI

Was ist Kimi K2.7 Code?

Kimi K2.7 Code ist ein auf Coding spezialisiertes Sprachmodell, das von Moonshot AI als Teil der Kimi K2-Familie entwickelt wurde. Das Modell richtet sich an professionelle Software-Engineering-Anwendungsfälle, die präzise Codegenerierung, Langkontextverständnis und iteratives Problemlösen erfordern.

Die Designphilosophie hinter K2.7 Code konzentriert sich darauf, Entwicklern die Arbeit mit vollständigen Projekten statt mit isolierten Snippets zu ermöglichen. Durch die Unterstützung extrem großer Kontexte kann das Modell Architekturentscheidungen, Implementierungsdetails, Test-Suites und Dokumentation gleichzeitig analysieren.

Innerhalb des Ökosystems von Moonshot AI nimmt Kimi K2.7 Code die Rolle eines leistungsfähigen Coding-Modells ein, das für Entwicklerproduktivität, Agentensysteme und Engineering-Automatisierung in Unternehmen vorgesehen ist.

Hauptfunktionen von Kimi K2.7 Code

1. Langkontext-Verständnis für Repositories

Das Kontextfenster von 256K Token ermöglicht es Entwicklern, große Repositories, API-Dokumentation, Architekturhinweise und unterstützende Materialien in einer einzigen Sitzung bereitzustellen.

2. Coding-zentrierte Optimierung

Im Gegensatz zu allgemeinen Konversationsmodellen priorisiert K2.7 Code Software-Engineering-Aufgaben einschließlich Implementierung, Debugging, Refactoring und Erläuterung.

3. Effizienz durch Mixture-of-Experts

Moonshot AI berichtet, dass das Modell während der Inferenz nur einen Teil seiner Gesamtparameter aktiviert und so Fähigkeit und Rechenaufwand ausbalanciert.

4. Unterstützung von Agent-Workflows

K2.7 Code ist darauf ausgelegt, iterative Coding-Workflows zu unterstützen, bei denen Planung, Ausführung, Validierung und Überarbeitung in mehreren Schritten erfolgen.

5. Schlussfolgern über mehrere Dateien

Entwickler können Abhängigkeiten und Interaktionen zwischen Komponenten analysieren, die über große Projekte verteilt sind.

Benchmark-Leistung von Kimi K2.7 Code

Zum Zeitpunkt der Erstellung ist die unabhängige Benchmark-Abdeckung für Kimi K2.7 Code weiterhin begrenzt.

Moonshot AI hat die folgenden Verbesserungen gegenüber früheren Kimi-Versionen veröffentlicht:

Benchmark	Gemeldete Verbesserung
Kimi Code Bench v2	+21,8%
Program Bench	+11,0%
MLS Bench Lite	+31,5%

Diese Zahlen stammen aus Anbieterkommunikationen und sollten als vom Anbieter berichtete Ergebnisse verstanden werden, nicht als unabhängig verifizierte Ranglisten.

Bedeutung der Benchmarks

Die gemeldeten Verbesserungen deuten darauf hin, dass Kimi K2.7 Code auf praktische Coding-Ergebnisse statt auf allgemeine Konversationsleistung fokussiert. Zugewinne in coding-orientierten Bewertungen können sich in besserem Repository-Verständnis, höherer Implementierungsgenauigkeit und gesteigerter Produktivität im Software-Engineering niederschlagen.

Kimi K2.7 Code vs ähnliche Modelle

Modell	Kontextfenster	Primärer Fokus	Stärken	Beste Anwendungsfälle
Kimi K2.7 Code	256K	Coding	Engineering-Workflows mit langem Kontext	Coding-Agents und Repository-Analyse
Claude Code Models	Groß	Coding und Reasoning	Starke Befolgung von Anweisungen	Coding-Assistenten für Unternehmen
GPT Coding Models	Groß	Allgemein + Coding	Breite Ökosystem-Unterstützung	Produktivanwendungen und Integrationen
DeepSeek Coding Models	Groß	Coding-Effizienz	Wettbewerbsfähige offene Deployments	Kostenbewusste Engineering-Teams

Zusammenfassung des Vergleichs

Kimi K2.7 Code differenziert sich durch die Kombination aus Langkontextverarbeitung und Coding-Spezialisierung. Organisationen, die Verständnis im Repository-Maßstab und Agent-Workflows priorisieren, können von seiner Architektur profitieren, während Teams, die breitere multimodale Fähigkeiten suchen, eher allgemeinere Alternativen bevorzugen.

Bekannte Einschränkungen

Maximale Grenzen für Ausgabetoken wurden nicht öffentlich offengelegt.
Unabhängige Benchmark-Validierung bleibt begrenzt.
Öffentliche Dokumentation spezifiziert das Verhalten für Funktionsaufrufe nicht.
Fähigkeiten für Vision, Audio und Video sind nicht dokumentiert.
Leistungsmerkmale außerhalb von Coding-Aufgaben sind weniger etabliert.
Leitfäden für Enterprise-Deployments sind im Vergleich zu reiferen Ökosystemen relativ begrenzt.

So verwenden Sie die Kimi K2.7 Code API auf CometAPI

Schritt 1: API-Schlüssel abrufen

Erstellen Sie ein CometAPI-Konto oder melden Sie sich an und generieren Sie einen API-Schlüssel. Verifizieren Sie, dass der neueste unterstützte Modellbezeichner lautet:

kimi-k2.7-code

Prüfen Sie vor dem Deployment die aktuelle Endpoint-Dokumentation, um die Kompatibilitätsanforderungen zu bestätigen.

Schritt 2: Modell testen

Beginnen Sie mit realistischen Entwicklungs-Prompts, die Ihre Produktionsumgebung widerspiegeln.

Beispielszenarien sind unter anderem:

Refactoring eines Legacy-Moduls.
Überprüfung eines Pull Requests.
Generieren von Unit-Tests.
Erläuterung der Repository-Architektur.
Implementierung von Features anhand von Spezifikationen.

Tests mit repräsentativen Workloads vermitteln ein klareres Verständnis des Modellverhaltens als synthetische Beispiele.

Schritt 3: In die Produktion integrieren

Wenn in Ihrer Umgebung unterstützt, verwenden Sie OpenAI-kompatible SDK-Muster, um die Einführung zu beschleunigen.

Empfehlungen für den Produktionseinsatz umfassen:

Aktivieren Sie Streaming-Antworten für eine bessere User Experience.
Implementieren Sie Wiederholungen mit exponentiellem Backoff.
Führen Sie Request- und Response-Logging.
Validieren Sie generierten Code vor der Ausführung.
Führen Sie für kritische Workflows menschliche Reviews ein.
Überwachen Sie Qualitätsmetriken anhand repräsentativer Engineering-Aufgaben.

Kimi K2.7 Code eignet sich besonders gut für agentenbasierte Entwicklungssysteme, in denen Planung, Implementierung, Verifikation und Iteration über den gesamten Softwarelebenszyklus hinweg kontinuierlich stattfinden.

Preise für Kimi K2.7 Code

Entdecken Sie wettbewerbsfähige Preise für Kimi K2.7 Code, die für verschiedene Budgets und Nutzungsanforderungen konzipiert sind. Unsere flexiblen Tarife stellen sicher, dass Sie nur für das bezahlen, was Sie nutzen, und erleichtern die Skalierung entsprechend Ihren wachsenden Anforderungen. Erfahren Sie, wie Kimi K2.7 Code Ihre Projekte verbessern kann, während die Kosten überschaubar bleiben.

Comet-Preis (USD / M Tokens)	Offizieller Preis (USD / M Tokens)	Rabatt
Eingabe:$0.76/M Ausgabe:$3.19998/M	Eingabe:$0.95/M Ausgabe:$3.999975/M	-20%

Beispielcode und API für Kimi K2.7 Code

Greifen Sie auf umfassende Beispielcodes und API-Ressourcen für Kimi K2.7 Code zu, um Ihren Integrationsprozess zu optimieren. Unsere detaillierte Dokumentation bietet schrittweise Anleitungen und hilft Ihnen dabei, das volle Potenzial von Kimi K2.7 Code in Ihren Projekten zu nutzen.

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

Versionen von Kimi K2.7 Code

Der Grund, warum Kimi K2.7 Code mehrere Snapshots hat, kann potenzielle Faktoren wie Änderungen der Ausgabe nach Updates umfassen, die ältere Snapshots für Konsistenz erfordern, Entwicklern eine Übergangszeit für Anpassung und Migration bieten und verschiedene Snapshots, die globalen oder regionalen Endpunkten entsprechen, um das Benutzererlebnis zu optimieren. Für detaillierte Unterschiede zwischen den Versionen lesen Sie bitte die offizielle Dokumentation.

version
kimi-k2.7-code