Kimi K2.6 ist das nativ multimodale Agentenmodell von Moonshot AI für langfristige Programmieraufgaben, codegestütztes Design und koordinierte Aufgabenausführung. Es verarbeitet Text, Bilder und Video und erzeugt Text, darunter Erklärungen, Code und vorgeschlagene Werkzeugaufrufe. Sein Mixture-of-Experts-Modellprofil nennt insgesamt eine Billion Parameter, 32 Milliarden aktive Parameter und einen Kontext von 256K sowie einen visuellen MoonViT-Encoder.
Der Hersteller entwickelt K2.6 für durchgängige Programmierarbeit über Sprachen und Domänen hinweg, darunter Repository-Arbeit, Frontend-Oberflächen und Leistungsoptimierung. Stelle den relevanten Code, das erwartete Verhalten, den beobachteten Fehler und die Bedingungen bereit, die die Änderung bewahren muss. Verbinde für eine visuelle Aufgabe die Anforderungen mit einem lesbaren Entwurf oder Screenshot und benenne, ob er den aktuellen Zustand oder das gewünschte Ergebnis zeigt.
Eine beispielhafte Anweisung lautet: „Implementiere diese Oberfläche anhand der bereitgestellten visuellen Spezifikation, bewahre die Feldnamen und erkläre das Verhalten jedes erforderlichen Zustands.“ Das erwartete Arbeitsergebnis ist Code samt stützender Erklärung, gefolgt von der tatsächlichen Darstellungs- oder Validierungsbeobachtung aus der Anwendung. Generierte Oberflächen und Textvorschläge sind keine unabhängig ausgeführten Handlungen.
K2.6 unterstützt Thinking- und Instant-Modi. Thinking entwickelt Zwischenschlussfolgerungen vor der endgültigen Antwort; der Instant-Modus erzeugt eine direkte Antwort. Die Bereitstellungsempfehlungen des Herstellers verwenden temperature 1.0 für Thinking, 0.6 für Instant und top-p 0.95. Dies sind Empfehlungen für seine dokumentierte Referenz, getrennt von der Wahl des Stils oder der Länge der endgültigen Antwort.
Eine spezifische K2.6-Funktion ist preserve-thinking, die den vollständigen Reasoning-Inhalt über Interaktionen mit mehreren Gesprächsschritten hinweg bewahrt. Sie ist standardmäßig deaktiviert und für Programmieragenten im Thinking-Modus dokumentiert. Bei ihrer Nutzung verbraucht die aufbewahrte Analyse zusammen mit Werkzeugbeobachtungen und endgültigen Antworten Kontext. Halte die akzeptierten Aufgabenanforderungen klar, damit ein früherer vorläufiger Gedanke nicht zu einem unbelegten Fakt im endgültigen Artefakt wird.
Die genaue Modellkarte demonstriert Bild- und Videoeingaben. Kennzeichne mehrere Medien, bewahre sichtbaren Text und nenne das Detail oder Ereignis, das du erklärt haben möchtest. Fordere bei einem Diagramm die beobachteten Werte getrennt von der Interpretation an. Benenne bei einem Video den relevanten Abschnitt und die zu analysierende zeitliche Veränderung. Der Hersteller kennzeichnet den demonstrierten Videoablauf in seiner Referenz als experimentell; Bild- und Videoverständnis erzeugt Text statt generierter Medien.
K2.6 verschränkt Thinking mit mehrstufigen Werkzeugaufrufen und dokumentiert einen Agentenschwarm-Ansatz des Herstellers, der eine Aufgabe in koordinierte, spezialisierte Zweige zerlegt. Die Anwendung stellt Werkzeuge bereit, führt gewählte Operationen aus und gibt ihre Beobachtungen zurück. Definiere erlaubte Handlungen und das endgültige Artefakt vor Beginn einer Agentenaufgabe, etwa einen abgeschlossenen Quellenvergleich, einen Repository-Patch oder ein vorbereitetes Dokument.
Bewahre jede zurückgegebene Beobachtung zusammen mit der Operation und Quelle, die sie erzeugt haben. Ein Zweig oder eine vorgeschlagene Werkzeughandlung wird erst dann zum nützlichen Beleg, wenn sein Ergebnis für die fortlaufende Aufgabe verfügbar ist. Die benannten Modi und Orchestrierungsdemonstrationen des Herstellers bedeuten nicht, dass eine gewöhnliche Textantwort selbstständig jede Hintergrundaktion oder anwendungsübergreifende Handlung ausführt.
K2.6 übernimmt das native INT4-Quantisierungsverfahren des Herstellers aus K2 Thinking. Dies ist eine dokumentierte Checkpoint-Eigenschaft und von einem Versprechen über die umgebende Ausführungskonfiguration getrennt. Sein Kontext von 256K muss Quelle, Dialog, optional bewahrtes Reasoning und gewünschte Ausgabe gemeinsam aufnehmen. Die Evaluationsbudgets der Modellkarte sind keine universellen Antwortgrenzen.
Prüfe Code anhand der Anforderungen, visuelle Befunde anhand der Eingabe und quellenabhängige Behauptungen anhand maßgeblichen Materials. Halte K2.6 von K2.5 und den reinen Textausgaben von K2 getrennt, insbesondere wenn preserve-thinking und Details visueller Abläufe für die Aufgabe wichtig sind.
", "aboutText": "Kimi K2.6 ist das nativ multimodale Agentenmodell von Moonshot AI für langfristige Programmieraufgaben, codegestütztes Design und koordinierte Aufgabenausführung. Es verarbeitet Text, Bilder und Video und erzeugt Text, darunter Erklärungen, Code und vorgeschlagene Werkzeugaufrufe. Sein Mixture-of-Experts-Modellprofil nennt insgesamt eine Billion Parameter, 32 Milliarden aktive Parameter und einen Kontext von 256K sowie einen visuellen MoonViT-Encoder.\n\n### Programmierung und visuelles Design\n\nDer Hersteller entwickelt K2.6 für durchgängige Programmierarbeit über Sprachen und Domänen hinweg, darunter Repository-Arbeit, Frontend-Oberflächen und Leistungsoptimierung. Stelle den relevanten Code, das erwartete Verhalten, den beobachteten Fehler und die Bedingungen bereit, die die Änderung bewahren muss. Verbinde für eine visuelle Aufgabe die Anforderungen mit einem lesbaren Entwurf oder Screenshot und benenne, ob er den aktuellen Zustand oder das gewünschte Ergebnis zeigt.\n\nEine beispielhafte Anweisung lautet: „Implementiere diese Oberfläche anhand der bereitgestellten visuellen Spezifikation, bewahre die Feldnamen und erkläre das Verhalten jedes erforderlichen Zustands.“ Das erwartete Arbeitsergebnis ist Code samt stützender Erklärung, gefolgt von der tatsächlichen Darstellungs- oder Validierungsbeobachtung aus der Anwendung. Generierte Oberflächen und Textvorschläge sind keine unabhängig ausgeführten Handlungen.\n\n### Thinking, Instant und bewahrtes Reasoning\n\nK2.6 unterstützt Thinking- und Instant-Modi. Thinking entwickelt Zwischenschlussfolgerungen vor der endgültigen Antwort; der Instant-Modus erzeugt eine direkte Antwort. Die Bereitstellungsempfehlungen des Herstellers verwenden temperature 1.0 für Thinking, 0.6 für Instant und top-p 0.95. Dies sind Empfehlungen für seine dokumentierte Referenz, getrennt von der Wahl des Stils oder der Länge der endgültigen Antwort.\n\nEine spezifische K2.6-Funktion ist preserve-thinking, die den vollständigen Reasoning-Inhalt über Interaktionen mit mehreren Gesprächsschritten hinweg bewahrt. Sie ist standardmäßig deaktiviert und für Programmieragenten im Thinking-Modus dokumentiert. Bei ihrer Nutzung verbraucht die aufbewahrte Analyse zusammen mit Werkzeugbeobachtungen und endgültigen Antworten Kontext. Halte die akzeptierten Aufgabenanforderungen klar, damit ein früherer vorläufiger Gedanke nicht zu einem unbelegten Fakt im endgültigen Artefakt wird.\n\n### Multimodale Eingaben\n\nDie genaue Modellkarte demonstriert Bild- und Videoeingaben. Kennzeichne mehrere Medien, bewahre sichtbaren Text und nenne das Detail oder Ereignis, das du erklärt haben möchtest. Fordere bei einem Diagramm die beobachteten Werte getrennt von der Interpretation an. Benenne bei einem Video den relevanten Abschnitt und die zu analysierende zeitliche Veränderung. Der Hersteller kennzeichnet den demonstrierten Videoablauf in seiner Referenz als experimentell; Bild- und Videoverständnis erzeugt Text statt generierter Medien.\n\n### Werkzeuge und Orchestrierung\n\nK2.6 verschränkt Thinking mit mehrstufigen Werkzeugaufrufen und dokumentiert einen Agentenschwarm-Ansatz des Herstellers, der eine Aufgabe in koordinierte, spezialisierte Zweige zerlegt. Die Anwendung stellt Werkzeuge bereit, führt gewählte Operationen aus und gibt ihre Beobachtungen zurück. Definiere erlaubte Handlungen und das endgültige Artefakt vor Beginn einer Agentenaufgabe, etwa einen abgeschlossenen Quellenvergleich, einen Repository-Patch oder ein vorbereitetes Dokument.\n\nBewahre jede zurückgegebene Beobachtung zusammen mit der Operation und Quelle, die sie erzeugt haben. Ein Zweig oder eine vorgeschlagene Werkzeughandlung wird erst dann zum nützlichen Beleg, wenn sein Ergebnis für die fortlaufende Aufgabe verfügbar ist. Die benannten Modi und Orchestrierungsdemonstrationen des Herstellers bedeuten nicht, dass eine gewöhnliche Textantwort selbstständig jede Hintergrundaktion oder anwendungsübergreifende Handlung ausführt.\n\n### Kontext und Umfang der Ausgabe\n\nK2.6 übernimmt das native INT4-Quantisierungsverfahren des Herstellers aus K2 Thinking. Dies ist eine dokumentierte Checkpoint-Eigenschaft und von einem Versprechen über die umgebende Ausführungskonfiguration getrennt. Sein Kontext von 256K muss Quelle, Dialog, optional bewahrtes Reasoning und gewünschte Ausgabe gemeinsam aufnehmen. Die Evaluationsbudgets der Modellkarte sind keine universellen Antwortgrenzen.\n\nPrüfe Code anhand der Anforderungen, visuelle Befunde anhand der Eingabe und quellenabhängige Behauptungen anhand maßgeblichen Materials. Halte K2.6 von K2.5 und den reinen Textausgaben von K2 getrennt, insbesondere wenn preserve-thinking und Details visueller Abläufe für die Aufgabe wichtig sind.", "editorialOverlay": { "copy_fields": { "practical_html": "Technisches Beispiel auf Englisch
Design a bounded table-sort function\n\nImplement a JavaScript function sortRows(rows, direction) for objects with a numeric score field. Return a new array, preserve input order for equal scores and support only asc or desc; reject other directions. Include examples with tied scores and tests proving the original array is unchanged. Explain how the tie rule is preserved.Function code, tie-order examples and tests for both directions, invalid direction and input preservation.Check that reversing an ascending result does not accidentally reverse equal-score rows.moonshotai/kimi-k2.6Kimi K2.6 ist das multimodale Agentenmodell von Moonshot AI für langfristige Programmieraufgaben, visuelle Oberflächenarbeit und werkzeuggestützte Aufgaben. Es verbindet Text, Bilder und Video mit Thinking- oder Instant-Antworten und dokumentiert die optionale Bewahrung von Reasoning über Gesprächsschritte hinweg in einem Kontext von 256K.
Diese Beschreibung erläutert die Fähigkeiten des Modells. Die über Ailoot verfügbaren Eingaben, Ausgaben und Optionen sind unten für die ausgewählte Methode aufgeführt.
Kimi K2.6 ist das nativ multimodale Agentenmodell von Moonshot AI für langfristige Programmieraufgaben, codegestütztes Design und koordinierte Aufgabenausführung. Es verarbeitet Text, Bilder und Video und erzeugt Text, darunter Erklärungen, Code und vorgeschlagene Werkzeugaufrufe. Sein Mixture-of-Experts-Modellprofil nennt insgesamt eine Billion Parameter, 32 Milliarden aktive Parameter und einen Kontext von 256K sowie einen visuellen MoonViT-Encoder.
Der Hersteller entwickelt K2.6 für durchgängige Programmierarbeit über Sprachen und Domänen hinweg, darunter Repository-Arbeit, Frontend-Oberflächen und Leistungsoptimierung. Stelle den relevanten Code, das erwartete Verhalten, den beobachteten Fehler und die Bedingungen bereit, die die Änderung bewahren muss. Verbinde für eine visuelle Aufgabe die Anforderungen mit einem lesbaren Entwurf oder Screenshot und benenne, ob er den aktuellen Zustand oder das gewünschte Ergebnis zeigt.
Eine beispielhafte Anweisung lautet: „Implementiere diese Oberfläche anhand der bereitgestellten visuellen Spezifikation, bewahre die Feldnamen und erkläre das Verhalten jedes erforderlichen Zustands.“ Das erwartete Arbeitsergebnis ist Code samt stützender Erklärung, gefolgt von der tatsächlichen Darstellungs- oder Validierungsbeobachtung aus der Anwendung. Generierte Oberflächen und Textvorschläge sind keine unabhängig ausgeführten Handlungen.
K2.6 unterstützt Thinking- und Instant-Modi. Thinking entwickelt Zwischenschlussfolgerungen vor der endgültigen Antwort; der Instant-Modus erzeugt eine direkte Antwort. Die Bereitstellungsempfehlungen des Herstellers verwenden temperature 1.0 für Thinking, 0.6 für Instant und top-p 0.95. Dies sind Empfehlungen für seine dokumentierte Referenz, getrennt von der Wahl des Stils oder der Länge der endgültigen Antwort.
Eine spezifische K2.6-Funktion ist preserve-thinking, die den vollständigen Reasoning-Inhalt über Interaktionen mit mehreren Gesprächsschritten hinweg bewahrt. Sie ist standardmäßig deaktiviert und für Programmieragenten im Thinking-Modus dokumentiert. Bei ihrer Nutzung verbraucht die aufbewahrte Analyse zusammen mit Werkzeugbeobachtungen und endgültigen Antworten Kontext. Halte die akzeptierten Aufgabenanforderungen klar, damit ein früherer vorläufiger Gedanke nicht zu einem unbelegten Fakt im endgültigen Artefakt wird.
Die genaue Modellkarte demonstriert Bild- und Videoeingaben. Kennzeichne mehrere Medien, bewahre sichtbaren Text und nenne das Detail oder Ereignis, das du erklärt haben möchtest. Fordere bei einem Diagramm die beobachteten Werte getrennt von der Interpretation an. Benenne bei einem Video den relevanten Abschnitt und die zu analysierende zeitliche Veränderung. Der Hersteller kennzeichnet den demonstrierten Videoablauf in seiner Referenz als experimentell; Bild- und Videoverständnis erzeugt Text statt generierter Medien.
K2.6 verschränkt Thinking mit mehrstufigen Werkzeugaufrufen und dokumentiert einen Agentenschwarm-Ansatz des Herstellers, der eine Aufgabe in koordinierte, spezialisierte Zweige zerlegt. Die Anwendung stellt Werkzeuge bereit, führt gewählte Operationen aus und gibt ihre Beobachtungen zurück. Definiere erlaubte Handlungen und das endgültige Artefakt vor Beginn einer Agentenaufgabe, etwa einen abgeschlossenen Quellenvergleich, einen Repository-Patch oder ein vorbereitetes Dokument.
Bewahre jede zurückgegebene Beobachtung zusammen mit der Operation und Quelle, die sie erzeugt haben. Ein Zweig oder eine vorgeschlagene Werkzeughandlung wird erst dann zum nützlichen Beleg, wenn sein Ergebnis für die fortlaufende Aufgabe verfügbar ist. Die benannten Modi und Orchestrierungsdemonstrationen des Herstellers bedeuten nicht, dass eine gewöhnliche Textantwort selbstständig jede Hintergrundaktion oder anwendungsübergreifende Handlung ausführt.
K2.6 übernimmt das native INT4-Quantisierungsverfahren des Herstellers aus K2 Thinking. Dies ist eine dokumentierte Checkpoint-Eigenschaft und von einem Versprechen über die umgebende Ausführungskonfiguration getrennt. Sein Kontext von 256K muss Quelle, Dialog, optional bewahrtes Reasoning und gewünschte Ausgabe gemeinsam aufnehmen. Die Evaluationsbudgets der Modellkarte sind keine universellen Antwortgrenzen.
Prüfe Code anhand der Anforderungen, visuelle Befunde anhand der Eingabe und quellenabhängige Behauptungen anhand maßgeblichen Materials. Halte K2.6 von K2.5 und den reinen Textausgaben von K2 getrennt, insbesondere wenn preserve-thinking und Details visueller Abläufe für die Aufgabe wichtig sind.
POST /v1/chat/completionstexttext| Feld | Typ | Anforderung | Werte und Limits | Standard |
|---|---|---|---|---|
Feldmodel | Typstring | AnforderungErforderlich | Werte und Limits moonshotai/kimi-k2.6 | Standard— |
Feldmessages | Typmessage[] | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
Feldmessages[].role | Typstring | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
Feldmessages[].content | Typstring|content_part[]|null | AnforderungOptional | Werte und Limits | Standard— |
Feldmessages[].tool_calls | Typtool_call[] | AnforderungOptional | Werte und Limits | Standard— |
Feldmessages[].tool_call_id | Typstring | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
Feldmessages[].name | Typstring | AnforderungOptional | Werte und Limits | Standard— |
Feldmessages[].reasoning_content | Typstring | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
Feldmessages[].reasoning_details | Typobject|array | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldmax_tokens | Typinteger | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
Feldmax_completion_tokens | Typinteger | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
Feldstream | Typboolean | AnforderungOptional | Werte und Limits | Standardfalse |
Feldstream_options.include_usage | Typboolean | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtemperature | Typnumber | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtop_p | Typnumber | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldstop | Typstring|string[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtools | Typfunction_tool[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtools[].type | Typstring | AnforderungOptional | Werte und Limits function Modellabhängig | Standard— |
Feldtools[].function.name | Typstring | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
Feldtools[].function.description | Typstring | AnforderungOptional | Werte und Limits | Standard— |
Feldtools[].function.parameters | TypJSON_schema | AnforderungOptional | Werte und Limits | Standard— |
Feldtool_choice | Typstring|object | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldparallel_tool_calls | Typboolean | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldresponse_format | Typobject | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldreasoning_effort | Typstring | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldreasoning | Typobject | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldservice_tier | Typstring | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldinstructions | Typstring | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
Feldfunctions | Typfunction[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldfunction_call | Typstring|object | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldprompt_cache_options | Typobject | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldmodalities | Typstring[] | AnforderungOptional | Werte und Limits text | Standard— |
Feldprovider | Typobject | AnforderungOptional | Werte und Limits Bedingungen: provider.options wird auf dieser Ultra-Textroute abgelehnt | Standard— |
Feldcache_control.ttl | Typstring | AnforderungOptional | Werte und Limits Bedingungen: 1h wird in den tatsächlichen Prompt-Cache-Feldern abgelehnt | Standard— |
Text · UTF8-Text
messages[].content
| Parameter | Vertrag |
|---|---|
Parametercontent_type | Vertragapplication/json |
Parameterrequired | Vertragmodel, messages |
Parametermaterial_types | Vertragtext |
Parametermessages | VertragNachrichtenarray mit role/content-Struktur |
Parameterfile_material | VertragTatsächliches UTF-8-Dokument als wörtlicher Text eingefügt; keine Datei-ID abgeleitet |
Parameteroptional_controls | Vertragstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Parametercontrol_scope | VertragModellspezifisch; benutzerseitige Funktionswerkzeuge unterscheiden sich von gehosteten Werkzeugen |
Parameteroutput_modalities | Vertragtext |
Parameterhosted_operations | Vertragfalse |
Parametermultimodal_input_binding | Vertragnull |
Lebenszyklus: synchronous_or_streamed
Die genaue Modell-ID zusammen mit messages senden.
Die Kontextlänge ist keine Ausgabeobergrenze.
Eine Textdatei kann wörtlichen Text liefern; Bild-, Audio- und Dateiobjekteingaben benötigen eine exakte Zuordnung.
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
|---|---|---|---|---|
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0019 / 1K Token Ausgabe · Ausgabetoken $0.008 / 1K Token Eingabe · Cache-Lesen $0.00032 / 1K Token Eingabe · Cache-Schreiben $0 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0019 / 1K Token Ausgabe · Ausgabetoken $0.008 / 1K Token Eingabe · Cache-Lesen $0.00032 / 1K Token Eingabe · Cache-Schreiben $0 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. So funktionieren Reservierung und Abrechnung →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "moonshotai/kimi-k2.6", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='moonshotai/kimi-k2.6',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='moonshotai/kimi-k2.6',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson oder SSE
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
| Feld | Typ |
|---|---|
Feldchoices[].index | Typinteger |
Feldchoices[].message.content | Typstring|null |
Feldchoices[].message.tool_calls | Typtool_call[] |
Feldchoices[].message.reasoning_content | Typstring |
Feldchoices[].message.reasoning_details | Typobject|array |
Feldchoices[].finish_reason | Typstring|null |
Feldusage | Typobject |
| Antwort | Bedingung | Nächster Schritt |
|---|---|---|
Antwort400 · invalid_request_error | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
Ailoot Ultra moonshotai/kimi-k2.6
Verwenden Sie die oben angezeigten Methodenpfade.
moonshotai/kimi-k2.6Kimi K2.6 ist das multimodale Agentenmodell von Moonshot AI für langfristige Programmieraufgaben, visuelle Oberflächenarbeit und werkzeuggestützte Aufgaben. Es verbindet Text, Bilder und Video mit Thinking- oder Instant-Antworten und dokumentiert die optionale Bewahrung von Reasoning über Gesprächsschritte hinweg in einem Kontext von 256K.
Diese Beschreibung erläutert die Fähigkeiten des Modells. Die über Ailoot verfügbaren Eingaben, Ausgaben und Optionen sind unten für die ausgewählte Methode aufgeführt.
Kimi K2.6 ist das nativ multimodale Agentenmodell von Moonshot AI für langfristige Programmieraufgaben, codegestütztes Design und koordinierte Aufgabenausführung. Es verarbeitet Text, Bilder und Video und erzeugt Text, darunter Erklärungen, Code und vorgeschlagene Werkzeugaufrufe. Sein Mixture-of-Experts-Modellprofil nennt insgesamt eine Billion Parameter, 32 Milliarden aktive Parameter und einen Kontext von 256K sowie einen visuellen MoonViT-Encoder.
Der Hersteller entwickelt K2.6 für durchgängige Programmierarbeit über Sprachen und Domänen hinweg, darunter Repository-Arbeit, Frontend-Oberflächen und Leistungsoptimierung. Stelle den relevanten Code, das erwartete Verhalten, den beobachteten Fehler und die Bedingungen bereit, die die Änderung bewahren muss. Verbinde für eine visuelle Aufgabe die Anforderungen mit einem lesbaren Entwurf oder Screenshot und benenne, ob er den aktuellen Zustand oder das gewünschte Ergebnis zeigt.
Eine beispielhafte Anweisung lautet: „Implementiere diese Oberfläche anhand der bereitgestellten visuellen Spezifikation, bewahre die Feldnamen und erkläre das Verhalten jedes erforderlichen Zustands.“ Das erwartete Arbeitsergebnis ist Code samt stützender Erklärung, gefolgt von der tatsächlichen Darstellungs- oder Validierungsbeobachtung aus der Anwendung. Generierte Oberflächen und Textvorschläge sind keine unabhängig ausgeführten Handlungen.
K2.6 unterstützt Thinking- und Instant-Modi. Thinking entwickelt Zwischenschlussfolgerungen vor der endgültigen Antwort; der Instant-Modus erzeugt eine direkte Antwort. Die Bereitstellungsempfehlungen des Herstellers verwenden temperature 1.0 für Thinking, 0.6 für Instant und top-p 0.95. Dies sind Empfehlungen für seine dokumentierte Referenz, getrennt von der Wahl des Stils oder der Länge der endgültigen Antwort.
Eine spezifische K2.6-Funktion ist preserve-thinking, die den vollständigen Reasoning-Inhalt über Interaktionen mit mehreren Gesprächsschritten hinweg bewahrt. Sie ist standardmäßig deaktiviert und für Programmieragenten im Thinking-Modus dokumentiert. Bei ihrer Nutzung verbraucht die aufbewahrte Analyse zusammen mit Werkzeugbeobachtungen und endgültigen Antworten Kontext. Halte die akzeptierten Aufgabenanforderungen klar, damit ein früherer vorläufiger Gedanke nicht zu einem unbelegten Fakt im endgültigen Artefakt wird.
Die genaue Modellkarte demonstriert Bild- und Videoeingaben. Kennzeichne mehrere Medien, bewahre sichtbaren Text und nenne das Detail oder Ereignis, das du erklärt haben möchtest. Fordere bei einem Diagramm die beobachteten Werte getrennt von der Interpretation an. Benenne bei einem Video den relevanten Abschnitt und die zu analysierende zeitliche Veränderung. Der Hersteller kennzeichnet den demonstrierten Videoablauf in seiner Referenz als experimentell; Bild- und Videoverständnis erzeugt Text statt generierter Medien.
K2.6 verschränkt Thinking mit mehrstufigen Werkzeugaufrufen und dokumentiert einen Agentenschwarm-Ansatz des Herstellers, der eine Aufgabe in koordinierte, spezialisierte Zweige zerlegt. Die Anwendung stellt Werkzeuge bereit, führt gewählte Operationen aus und gibt ihre Beobachtungen zurück. Definiere erlaubte Handlungen und das endgültige Artefakt vor Beginn einer Agentenaufgabe, etwa einen abgeschlossenen Quellenvergleich, einen Repository-Patch oder ein vorbereitetes Dokument.
Bewahre jede zurückgegebene Beobachtung zusammen mit der Operation und Quelle, die sie erzeugt haben. Ein Zweig oder eine vorgeschlagene Werkzeughandlung wird erst dann zum nützlichen Beleg, wenn sein Ergebnis für die fortlaufende Aufgabe verfügbar ist. Die benannten Modi und Orchestrierungsdemonstrationen des Herstellers bedeuten nicht, dass eine gewöhnliche Textantwort selbstständig jede Hintergrundaktion oder anwendungsübergreifende Handlung ausführt.
K2.6 übernimmt das native INT4-Quantisierungsverfahren des Herstellers aus K2 Thinking. Dies ist eine dokumentierte Checkpoint-Eigenschaft und von einem Versprechen über die umgebende Ausführungskonfiguration getrennt. Sein Kontext von 256K muss Quelle, Dialog, optional bewahrtes Reasoning und gewünschte Ausgabe gemeinsam aufnehmen. Die Evaluationsbudgets der Modellkarte sind keine universellen Antwortgrenzen.
Prüfe Code anhand der Anforderungen, visuelle Befunde anhand der Eingabe und quellenabhängige Behauptungen anhand maßgeblichen Materials. Halte K2.6 von K2.5 und den reinen Textausgaben von K2 getrennt, insbesondere wenn preserve-thinking und Details visueller Abläufe für die Aufgabe wichtig sind.
POST /v1/messagestextjson, sse| Feld | Typ | Anforderung | Werte und Limits | Standard |
|---|---|---|---|---|
Feldmodel | Typstring | AnforderungErforderlich | Werte und Limits moonshotai/kimi-k2.6 | Standard— |
Feldmessages | Typmessage[] | AnforderungErforderlich | Werte und Limits | Standard— |
Feldmessages[].role | Typstring | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
Feldmessages[].content | Typstring | AnforderungErforderlich | Werte und Limits | Standard— |
Feldmax_tokens | Typinteger | AnforderungErforderlich | Werte und Limits | Standard— |
Feldstream | Typboolean | AnforderungOptional | Werte und Limits | Standardfalse |
Text · UTF-8-Text
Zeichenfolge messages[].content
| Parameter | Vertrag |
|---|---|
Parametercontent_type | Vertragapplication/json |
Parameterrequired | Vertragmodel, messages, max_tokens |
Parameteroptional_controls | Vertragstream |
Parametermaterial_types | Vertragtext |
Parametertext_file_material | VertragDas tatsächliche UTF-8-Dokument lesen und seinen Text in die angegebene Zeichenfolge für Eingabe oder Nachrichteninhalt einfügen. |
Lebenszyklus: synchronous_or_streamed
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
|---|---|---|---|---|
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0019 / 1K Token Ausgabe · Ausgabetoken $0.008 / 1K Token Eingabe · Cache-Lesen $0.00032 / 1K Token Eingabe · Cache-Schreiben $0 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0019 / 1K Token Ausgabe · Ausgabetoken $0.008 / 1K Token Eingabe · Cache-Lesen $0.00032 / 1K Token Eingabe · Cache-Schreiben $0 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. So funktionieren Reservierung und Abrechnung →
{\n "model": "moonshotai/kimi-k2.6",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'moonshotai/kimi-k2.6', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'moonshotai/kimi-k2.6', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON oder SSE
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
| Feld | Typ |
|---|---|
Feldid | Typstring |
Feldmodel | Typstring |
Feldcontent[] | Typtext|thinking|tool_use|other content block |
Feldstop_reason | Typstring|null |
Feldusage | Typobject |
| Antwort | Bedingung | Nächster Schritt |
|---|---|---|
Antwort400 · invalid_request_error | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
Ailoot Ultra moonshotai/kimi-k2.6
Verwenden Sie die oben angezeigten Methodenpfade.
Technisches Beispiel auf Englisch
Design a bounded table-sort function\n\nImplement a JavaScript function sortRows(rows, direction) for objects with a numeric score field. Return a new array, preserve input order for equal scores and support only asc or desc; reject other directions. Include examples with tied scores and tests proving the original array is unchanged. Explain how the tie rule is preserved.Function code, tie-order examples and tests for both directions, invalid direction and input preservation.Check that reversing an ascending result does not accidentally reverse equal-score rows.