DEV Community

Cover image for Wie benutzt man die Kimi K3 API?
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

Wie benutzt man die Kimi K3 API?

Moonshot AI hat Kimi K3 am 16. Juli 2026 ausgeliefert und es als ihr bisher leistungsfähigstes Modell bezeichnet: das weltweit erste offene Modell der 3T-Klasse mit einem 2.8T-Parameter-Mixture-of-Experts-Design und einem 1.048.576-Token-Kontextfenster. Für Entwickler ist vor allem die API relevant: Kimi K3 spricht den OpenAI-SDK-Dialekt. Wenn Sie bereits GPT oder einen anderen OpenAI-kompatiblen Endpunkt nutzen, können Sie denselben Client auf kimi-k3 umstellen und innerhalb weniger Minuten Antworten streamen. Dieser Leitfaden zeigt den API-Key-Setup, Schnellstarts mit Python, JavaScript und cURL, Streaming, Tool-Aufrufe, JSON-Modus, reasoning_effort, Kontext-Caching sowie das Testen und Debuggen in Apidog.

Apidog noch heute ausprobieren

TL;DR

  • Die API-Modell-ID lautet kimi-k3. Auf OpenRouter lautet der Slug moonshotai/kimi-k3.
  • Der Endpunkt ist OpenAI-SDK-kompatibel. Setzen Sie base_url, api_key und model="kimi-k3". Bestätigen Sie die genaue Basis-URL in der Konsole unter platform.kimi.ai; Kimi hat historisch https://api.moonshot.ai/v1 verwendet.
  • Das Kontextfenster umfasst 1 Million Tokens. Die Preise betragen $0.30 pro Million Cache-Hit-Input-Tokens, $3.00 pro Million Cache-Miss-Input-Tokens und $15.00 pro Million Output-Tokens.
  • Streaming, Tool-Aufrufe, JSON-Modus, strukturierte Ausgabe und der Parameter reasoning_effort funktionieren über das Standardformat für Chat Completions.
  • Für ältere oder preisgünstigere Coding-Workloads kann die K2.7-Linie besser passen.
  • Importieren Sie Anfragen in Apidog, um Streaming zu prüfen, Tool-Aufrufe zu debuggen, Schlüssel als Umgebungsvariablen zu speichern und kimi-k3 gegen kimi-k2-7-code zu testen.

Welches Kimi-Modell sollten Sie aufrufen?

Wählen Sie das Modell vor der Implementierung anhand Ihres Workloads.

Kimi K3 ist das führende Modell der Familie: ein großes MoE für komplexe Coding-Aufgaben, langfristige Agentenarbeit und Wissensaufgaben mit langen Kontexten. Es hat die höchsten Output-Kosten innerhalb der Modellreihe. Moonshots eigener Launch-Beitrag räumt außerdem ein, dass K3 in internen Vergleichen hinter Claude Fable 5 und GPT-5.6 Sol liegt. Es ist leistungsfähig, aber kein eindeutiger Spitzenreiter und entsprechend bepreist.

Kimi-K3-Modellvergleich

Für hochvolumige Coding-Assistenten, CI-Testgeneratoren oder andere Workloads mit hohen Aufrufzahlen ist die ältere K2.7-Code-Linie oft kosteneffizienter.

Nutzen Sie diese Ressourcen für die Auswahl:

Verwenden Sie kimi-k3, wenn Sie die zusätzliche Argumentationstiefe, den vollständigen 1M-Kontext oder agentische Tool-Orchestrierung benötigen. Wechseln Sie zu K2.7, wenn die Aufgabe routinemäßig ist und das Volumen hoch ist.

API-Schlüssel auf der Kimi-Plattform erhalten

Öffnen Sie platform.kimi.ai und melden Sie sich an. In der Konsole erstellen Sie API-Schlüssel, überwachen die Nutzung und sehen die für Ihr Konto gültige Basis-URL.

Kimi-Plattform-Konsole

  1. Öffnen Sie in der Konsole den Bereich für API-Schlüssel.
  2. Erstellen Sie einen neuen Schlüssel.
  3. Kopieren Sie den Schlüssel sofort und speichern Sie ihn sicher. Der vollständige Wert wird später nicht erneut angezeigt.
  4. Fügen Sie Guthaben hinzu oder prüfen Sie Ihre Abrechnungsstufe.
  5. Notieren Sie die in der Konsole angezeigte Basis-URL. Historisch verwendete Kimi https://api.moonshot.ai/v1; die Konsole ist jedoch die maßgebliche Quelle für Ihr Konto.

Exportieren Sie den Schlüssel als Umgebungsvariable:

export KIMI_API_KEY="sk-your-key-here"
Enter fullscreen mode Exit fullscreen mode

Hinterlegen Sie API-Schlüssel niemals direkt im Quellcode. So vermeiden Sie Leaks in Git-Historien, Pull Requests und Screenshots.

Für Details zu Cache-Hits, Cache-Misses und deren Einfluss auf Monatskosten lesen Sie den Kimi K3-Preisleitfaden.

Schnellstart: Ihr erster kimi-k3-Aufruf

Kimis API folgt dem OpenAI-Chat-Completions-Vertrag. Sie können daher die offiziellen OpenAI-SDKs verwenden und müssen hauptsächlich zwei Werte ändern:

  • base_url
  • model="kimi-k3"

Python

Installieren Sie zuerst das SDK:

pip install openai
Enter fullscreen mode Exit fullscreen mode

Dann senden Sie eine Chat-Completion:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["KIMI_API_KEY"],
    # Bestätigen Sie die Basis-URL in der Kimi-Konsole.
    # Kimi hat historisch den folgenden Wert verwendet.
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "You are a precise coding assistant."},
        {
            "role": "user",
            "content": "Explain what a token bucket rate limiter does in one paragraph.",
        },
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

JavaScript / TypeScript

Installieren Sie das SDK:

npm install openai
Enter fullscreen mode Exit fullscreen mode

Dann erstellen Sie den Client:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  // Bestätigen Sie die Basis-URL in der platform.kimi.ai-Konsole.
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    { role: "system", content: "You are a precise coding assistant." },
    {
      role: "user",
      content: "Explain what a token bucket rate limiter does in one paragraph.",
    },
  ],
});

console.log(response.choices[0].message.content);
Enter fullscreen mode Exit fullscreen mode

cURL

Setzen Sie zusätzlich die Basis-URL aus Ihrer Kimi-Konsole:

export KIMI_BASE_URL="https://api.moonshot.ai/v1"
Enter fullscreen mode Exit fullscreen mode

Senden Sie dann die Anfrage:

curl "$KIMI_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {
        "role": "user",
        "content": "Explain what a token bucket rate limiter does in one paragraph."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Häufige Fehler beim ersten Request

  • HTTP 401: Der API-Schlüssel fehlt, ist falsch oder wird nicht korrekt als Umgebungsvariable geladen.
  • HTTP 404: Meist ist die Basis-URL oder der Pfad falsch, nicht die Modell-ID.
  • Verbindungsfehler: Prüfen Sie, ob Ihre Anwendung tatsächlich die Basis-URL aus der Konsole verwendet.

Die OpenAI Python SDK-Dokumentation beschreibt die Client-Optionen im Detail. Da Kimi das gleiche Übertragungsformat verwendet, gelten diese Optionen auch hier.

Streaming-Antworten

Für Chat-UIs und längere Agentenläufe sollten Sie Tokens ausgeben, sobald sie eintreffen. Aktivieren Sie dafür stream=True.

Python-Streaming 

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Write a 6-line poem about flaky tests.",
        }
    ],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta

    if delta.content:
        print(delta.content, end="", flush=True)
Enter fullscreen mode Exit fullscreen mode

JavaScript-Streaming 

const stream = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    {
      role: "user",
      content: "Write a 6-line poem about flaky tests.",
    },
  ],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
Enter fullscreen mode Exit fullscreen mode

Unter der Haube verwendet Streaming Server-Sent Events (SSE). Die Antwort enthält einzelne data:-Frames mit JSON-Chunks und endet mit:

data: [DONE]
Enter fullscreen mode Exit fullscreen mode

Das SDK abstrahiert diese Frames. Das ist praktisch im Produktionscode, kann das Debugging aber erschweren, wenn ein Stream mitten in der Antwort abbricht.

Tool-Aufrufe (Funktionsaufrufe)

Kimi K3 unterstützt Tool-Aufrufe, Tool-Auswahl-Beschränkungen und dynamisches Tool-Laden. Damit können Sie Agenten bauen, die Dateien lesen, APIs aufrufen oder Terminalbefehle ausführen.

Definieren Sie Ihre Tools mit JSON Schema:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name, e.g. Singapore",
                    },
                },
                "required": ["city"],
            },
        },
    }
]

messages = [
    {
        "role": "user",
        "content": "What's the weather in Singapore right now?",
    }
]

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

tool_call = first.choices[0].message.tool_calls[0]

print(tool_call.function.name)       # get_weather
print(tool_call.function.arguments)  # {"city": "Singapore"}
Enter fullscreen mode Exit fullscreen mode

Wichtig: Das Modell führt Ihre Funktion nicht selbst aus. Es liefert nur den Funktionsnamen und die JSON-Argumente. Ihre Anwendung führt den Aufruf aus und sendet das Ergebnis zurück:

import json

messages.append(first.choices[0].message)

messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps({
        "city": "Singapore",
        "temp_c": 31,
        "sky": "humid",
    }),
})

final = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
)

print(final.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Sie können Tool-Aufrufe gezielt steuern:

tool_choice = "required"
Enter fullscreen mode Exit fullscreen mode

Oder Sie erzwingen eine bestimmte Funktion:

tool_choice = {
    "type": "function",
    "function": {
        "name": "get_weather",
    },
}
Enter fullscreen mode Exit fullscreen mode

Das ist nützlich, wenn Ihr Agent bereits weiß, welches Tool für den nächsten Schritt erforderlich ist.

K3-spezifischer Hinweis: Das Modell wurde im Modus „preserved-thinking-history“ trainiert. Wenn Ihr Agenten-Framework frühere Assistentenrunden entfernt, kann die Generierungsqualität instabil werden. Geben Sie bei mehrstufigen Agenten die vollständige Nachrichtenhistorie zurück, statt interne Gesprächsrunden zu kürzen.

JSON-Modus und strukturierte Ausgabe

Wenn Ihre Anwendung maschinenlesbare Daten erwartet, lassen Sie das Modell JSON liefern, statt Prosa zu parsen.

JSON-Modus 

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "system",
            "content": "Return only valid JSON. No prose, no markdown.",
        },
        {
            "role": "user",
            "content": "Extract name and role from: 'Ada Lovelace, mathematician'.",
        },
    ],
    response_format={"type": "json_object"},
)

print(response.choices[0].message.content)
# {"name": "Ada Lovelace", "role": "mathematician"}
Enter fullscreen mode Exit fullscreen mode

Validieren Sie die Antwort dennoch in Ihrer Anwendung:

import json

data = json.loads(response.choices[0].message.content)

assert isinstance(data["name"], str)
assert isinstance(data["role"], str)
Enter fullscreen mode Exit fullscreen mode

Strukturierte Ausgabe mit JSON Schema

Wenn Ihre SDK-Version und Ihr Konto json_schema unterstützen, können Sie eine feste Antwortform vorgeben:

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Extract name and role from: 'Ada Lovelace, mathematician'.",
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "role": {"type": "string"},
                },
                "required": ["name", "role"],
            },
        },
    },
)
Enter fullscreen mode Exit fullscreen mode

Prüfen Sie die json_schema-Unterstützung vor dem produktiven Einsatz in Ihrer Konsole. Wenn Sie unsicher sind, verwenden Sie json_object und validieren Sie das Ergebnis serverseitig.

Kimi bietet außerdem einen Teillmodus und Internetrecherche. Das kann nützlich sein, um Antworten vorab auszufüllen oder sie auf aktuellen Daten aufzubauen.

Konfigurierbarer Argumentationsaufwand

Kimi K3 stellt den Parameter reasoning_effort bereit. Er beeinflusst, wie stark das Modell vor der Antwort nachdenkt.

Der aktuell verfügbare Wert ist max, der zugleich Standard ist. Moonshot hat weitere niedrigere und höhere Stufen angekündigt.

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Plan a migration from REST to GraphQL for a 40-endpoint API.",
        }
    ],
    reasoning_effort="max",
)
Enter fullscreen mode Exit fullscreen mode

Mehr Argumentationsaufwand bedeutet höhere Output-Token-Kosten und mehr Latenz. Setzen Sie ihn daher gezielt für Planungs-, Analyse- und komplexe Architekturaufgaben ein.

Falls Ihre installierte OpenAI-SDK-Version das Feld noch nicht kennt, verwenden Sie extra_body:

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Plan a migration from REST to GraphQL.",
        }
    ],
    extra_body={
        "reasoning_effort": "max",
    },
)
Enter fullscreen mode Exit fullscreen mode

extra_body ist der Escape Hatch für anbieterspezifische Felder, die von einem kompatiblen Endpunkt unterstützt werden, aber im SDK noch nicht modelliert sind.

kimi-k3 in Apidog testen und debuggen

SDKs vereinfachen Produktionscode, blenden aber die HTTP-Details aus. Das wird problematisch, wenn ein Tool-Aufruf falsche Argumente liefert oder ein SSE-Stream abbricht.

Mit Apidog können Sie die rohe kimi-k3-Anfrage senden, SSE-Frames untersuchen und API-Schlüssel als Umgebungsvariablen speichern. Der Workflow ist besonders nützlich, wenn Sie nicht nur cURL-Ausgaben lesen, sondern Anfragen wiederholbar speichern und mit Ihrem Team teilen möchten.

Kimi K3 in Apidog testen

Schritt-für-Schritt-Workflow

  1. Erstellen Sie in Apidog eine neue HTTP-Anfrage.
  2. Setzen Sie die Methode auf POST.
  3. Verwenden Sie als URL: 
   https://api.moonshot.ai/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Ersetzen Sie die URL bei Bedarf durch die Basis-URL aus Ihrer Kimi-Konsole.

  1. Erstellen Sie eine Umgebungsvariable namens KIMI_API_KEY.
  2. Setzen Sie den Header: 
   Authorization: Bearer {{KIMI_API_KEY}}
Enter fullscreen mode Exit fullscreen mode
  1. Setzen Sie außerdem: 
   Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode
  1. Fügen Sie diesen JSON-Body ein: 
   {
     "model": "kimi-k3",
     "messages": [
       {
         "role": "user",
         "content": "Explain what a token bucket rate limiter does in one paragraph."
       }
     ]
   }
Enter fullscreen mode Exit fullscreen mode
  1. Senden Sie die Anfrage und prüfen Sie Antwortinhalt sowie Token-Nutzung.
  2. Aktivieren Sie Streaming: 
   {
     "model": "kimi-k3",
     "stream": true,
     "messages": [
       {
         "role": "user",
         "content": "Write a 6-line poem about flaky tests."
       }
     ]
   }
Enter fullscreen mode Exit fullscreen mode
  1. Prüfen Sie die einzelnen SSE-Frames und suchen Sie nach unvollständigen oder fehlerhaften data:-Chunks.

Für Tool-Aufrufe prüfen Sie insbesondere das Feld tool_calls. So erkennen Sie, ob das Modell ungültiges JSON erzeugt hat oder ob Ihr Tool-Schema mehrdeutig ist.

Für einen Modellvergleich duplizieren Sie die Anfrage, ändern nur das Modell und vergleichen dieselben Prompts:

{
  "model": "kimi-k2-7-code"
}
Enter fullscreen mode Exit fullscreen mode

Vergleichen Sie anschließend:

  • Latenz
  • Ausgabequalität
  • Tool-Call-Qualität
  • Token-Verbrauch
  • Kosten

Das ist der direkteste Weg, um zu entscheiden, ob K3 für Ihren Anwendungsfall den Preisaufschlag wert ist.

Da Apidog OpenAI-kompatible Anfragen direkt importieren kann, können Sie auch einen cURL-Befehl einfügen und daraus eine gespeicherte Anfrage mit Headers und Body erzeugen. Der Leitfaden APIs testen ohne Postman beschreibt diesen allgemeinen Workflow.

Wenn Ihr Agent per MCP mit dem Modell kommuniziert, zeigt der Leitfaden zum visuellen Debugging mit dem Apidog MCP-Client, wie Sie diese Aufrufe ebenfalls verfolgen können. Sie können Apidog herunterladen, um den Ablauf mit Ihrem eigenen Schlüssel nachzuvollziehen.

Anwendungsfälle in der Praxis

Diese Muster passen zu den Stärken von kimi-k3:

  • Repository-weite Coding-Agenten: Der 1M-Kontext und die Tool-Orchestrierung ermöglichen es dem Modell, große Codebasen zu verwalten, Tests auszuführen, Logs zu lesen und iterativ vorzugehen. Cachen Sie einen stabilen Codebasis-Digest als Präfix, um Kosten pro Durchlauf zu senken.

  • Wissensarbeit mit langen Dokumenten: Übergeben Sie vollständige Spezifikationen, Verträge oder Forschungsbestände und fordern Sie strukturierte Extraktion mit json_schema an. Platzieren Sie das Dokument am Anfang des Prompts, damit wiederholte Anfragen den Cache treffen können.

  • Migrations- und Refactoring-Planung: Nutzen Sie reasoning_effort="max" für den Planungsdurchlauf. Wechseln Sie für mechanische Änderungen anschließend zu einem günstigeren Modell.

  • Fundierte Forschungsantworten: Mit Internetsuche und Tool-Aufrufen kann K3 aktuelle Daten abrufen und zitieren. Das eignet sich für Assistenten, die nicht ausschließlich auf Trainingswissen angewiesen sein sollen.

Der Ablauf bleibt dabei gleich:

  1. Anfrage im SDK implementieren.
  2. Rohverhalten in Apidog prüfen.
  3. Fehlerfälle für Streaming, Tools und JSON-Ausgaben testen.
  4. Erst danach in die Anwendung integrieren.

Zusammenfassung

Für Kimi K3 brauchen Sie mit einem OpenAI-kompatiblen Client nur drei zentrale Einstellungen:

base_url
api_key
model="kimi-k3"
Enter fullscreen mode Exit fullscreen mode

Streaming, Tool-Aufrufe, JSON-Modus, strukturierte Ausgabe und reasoning_effort folgen danach dem bekannten Chat-Completions-Vertrag.

Behalten Sie zwei Punkte im Blick:

  1. Kontext-Caching: Ein stabiles Prompt-Präfix kann Input-Kosten von $3.00 auf $0.30 pro Million Tokens reduzieren.
  2. Modellauswahl: K3 bietet Argumentationstiefe zu realen Kosten. Leiten Sie routinemäßige und hochvolumige Coding-Aufgaben bei Bedarf an die K2.7-Linie weiter.

Implementieren Sie die Anfrage im Code, prüfen Sie sie als rohe HTTP-Anfrage in Apidog und übernehmen Sie sie anschließend kontrolliert in Ihre Anwendung.

FAQ

Wie lautet die API-Modell-ID für Kimi K3?

Auf Kimis eigener Plattform lautet sie:

kimi-k3
Enter fullscreen mode Exit fullscreen mode

Über OpenRouter verwenden Sie:

moonshotai/kimi-k3
Enter fullscreen mode Exit fullscreen mode

Die Modellseite finden Sie unter openrouter.ai/moonshotai/kimi-k3.

Welche Basis-URL verwende ich?

Bestätigen Sie die Basis-URL in der Konsole unter platform.kimi.ai. Historisch hat Kimi verwendet:

https://api.moonshot.ai/v1
Enter fullscreen mode Exit fullscreen mode

Halten Sie die URL als Konfigurationsvariable und codieren Sie sie nicht dauerhaft im Quellcode.

Ist Kimi K3 mit dem OpenAI SDK kompatibel?

Ja. Die API folgt dem OpenAI-Chat-Completions-Format. Die offiziellen Python- und JavaScript-SDKs funktionieren, nachdem Sie base_url und model gesetzt haben. Anbieterspezifische Felder können Sie mit extra_body senden.

Wie viel kostet die Kimi-K3-API?

Die Preise betragen:

Typ Preis pro 1 Million Tokens
Cache-Hit-Input $0.30
Cache-Miss-Input $3.00
Output $15.00

Die Wiederverwendung stabiler Prompt-Präfixe ist der wichtigste Hebel zur Kostenoptimierung. Details finden Sie im Kimi K3-Preisleitfaden.

Was bewirkt Kontext-Caching?

Wenn die führenden Tokens einer Anfrage mit einer vorherigen Anfrage übereinstimmen, kann der Endpunkt bereits berechneten Zustand wiederverwenden. Die Input-Kosten für diesen Teil sinken dadurch von $3.00 auf $0.30 pro Million Tokens.

Platzieren Sie deshalb stabile Inhalte am Anfang des Prompts:

  • System-Prompt
  • Gemeinsame Tool-Definitionen
  • Codebasis-Digest
  • Wiederverwendete Dokumente oder Spezifikationen

Kann ich steuern, wie stark das Modell nachdenkt?

Ja, über reasoning_effort.

Der aktuell verfügbare Wert ist:

max
Enter fullscreen mode Exit fullscreen mode

Das ist zugleich der Standard. Höherer Argumentationsaufwand erhöht Output-Token-Verbrauch und Latenz.

Sollte ich Kimi K3 oder Kimi K2.7 Code verwenden?

Verwenden Sie kimi-k3, wenn Sie Folgendes benötigen:

  • tiefe Argumentation
  • vollständigen 1M-Kontext
  • agentische Tool-Orchestrierung

Für hochvolumige und routinemäßige Coding-Aufgaben ist die K2.7-Linie oft kosteneffizienter. Nutzen Sie den Vergleich Kimi K3 vs. Kimi K2.7 Code sowie den Kimi K2.7 Code API-Leitfaden für die Entscheidung.

Wie debugge ich fehlerhafte Streaming- oder Tool-Call-Antworten?

Senden Sie die Roh-Anfrage in Apidog:

  • Aktivieren Sie "stream": true, um SSE-Frames einzeln zu prüfen.
  • Kontrollieren Sie bei Tool-Aufrufen das Array tool_calls.
  • Speichern Sie den Schlüssel als Umgebungsvariable, statt ihn im Request-Body oder Header fest einzutragen.
  • Vergleichen Sie dieselbe Anfrage mit kimi-k3 und kimi-k2-7-code, um Modellverhalten, Latenz und Kosten gegenüberzustellen.

Top comments (0)