MoonshotAI: Kimi K3 (batch)

Kimi K3 är Moonshot AI:s från grunden multimodala resonemangsmodell för långa koduppgifter och kunskapsarbete. Den läser text, bilder och video, producerar text och stöder verktygsdrivna arbetsflöden med en kontext på 1 048 576 token och bevarad resonemangshistorik mellan steg.

Ailoot Ultra · Batchkörning POST /v1/batches moonshotai/kimi-k3:batch

Om modellen

Den här beskrivningen omfattar modellens förmågor. Tillgängliga indata, utdata och alternativ i Ailoot anges nedan för den valda metoden.

Kimi K3 är Moonshot AI:s multimodala agentmodell med öppna vikter för långsiktigt kodarbete, kunskapsarbete och resonemang. Den kombinerar text med inbyggd bildförståelse av bilder och video och producerar ett textsvar eller en verktygsbegäran. Tillverkaren framhåller långa utvecklingssessioner, stora kodarkiv och uppgifter som använder skärmbilder eller visuell återkoppling tillsammans med kod. Ett användbart uppdragsunderlag definierar önskad leverans, underlaget som ska användas och villkoret som markerar att arbetet är klart.

Arkitektur och lång kontext

Modellkortet beskriver en gles Mixture of Experts med totalt 2,8 biljoner parametrar och 104 miljarder aktiverade parametrar. Dess Stable LatentMoE-utformning väljer 16 av 896 experter per token och använder Kimi Delta Attention och Attention Residuals tillsammans med grindstyrd uppmärksamhet. Den exakta kontextlängden är 1 048 576 token. Det ger plats för en omfattande uppgiftskontext, inte ett skäl att bortse från källavgränsningar eller utrymmet som resultatet behöver.

Den publicerade ursprungliga modellleveransen använder kvantiseringsmedveten träning med MXFP4-vikter och MXFP8-aktiveringar. Det är tillverkarens publiceringsformat, skilt från en separat tillhandahållen kvantiserad utgåva eller ett påstående om hur en viss rutt tillhandahåller modellen. Öppna vikter och ett stort parameterantal gör inte antalet aktiva parametrar till det totala lagrings- eller maskinvarukravet.

Förbered en omfattande koduppgift

Tillhandahåll relevant material från kodarkivet, det befintliga beteendet, den begärda ändringen och kompatibilitetsbegränsningarna. Identifiera filerna eller gränssnittet som resultatet måste påverka, kontrollerna som avgör framgång och eventuella tillhandahållna fel eller indata som visar problemet. Ett användbart resultat kan vara en avgränsad kodändring med en förklaring och underlag från kontrollerna som faktiskt kördes, snarare än en beskrivning av åtgärder som aldrig utfördes.

För en visuell utvecklingsuppgift inkluderar du en skärmbild eller en tydlig vy av det avsedda resultatet med relevant kod och en specifik avvikelse. Tillverkaren beskriver flöden som omfattar frontendarbete, spel och CAD och använder visuell återkoppling. Begär ändringen som kopplar koden till det observerade resultatet och bevara referensen så att den levererade artefakten kan kontrolleras mot den.

Bilder, video och förberedelse för kunskapsarbete

Producentens snabbstart använder typade innehållsobjekt för visuella meddelanden; content är en array, inte en serialiserad representation av den arrayen. Bildflödet använder kodade bilddata eller en stödd filreferens snarare än en offentlig bildadress. Videoexemplet laddar upp en videofil och anger den resulterande referensen med en fråga om innehållet. Tillhandahåll en läsbar källa och ange observationen, intervallet eller sambandet som är viktigt. Producentens bildflöde accepterar bilder i JPEG, PNG, GIF, WebP, BMP, HEIC och HEIF samt video i MP4, MPEG, MOV, AVI, FLV, MPG, WebM, WMV och 3GPP. Animerad GIF eller WebP kan avkodas som video. Tillhandahåll SVG-källkod som text. Tillverkaren rekommenderar bilder på upp till 4 096 × 2 160 och video på upp till 1 920 × 1 080; detta är upplösningsrekommendationer, inte avvisningsgränser. Håll begärandekroppen inom den dokumenterade storleksgränsen 100M och ladda upp stora eller återkommande medier som filer.

För dokumenttung forskning märker du upp källorna och anger frågorna som slutrapporten ska besvara. För en videoförklaring identifierar du händelserna eller sekvensen som ska analyseras i stället för att begära obegränsade kommentarer. K3 använder visuellt innehåll som underlag för resonemang och returnerar text eller verktygsbegäranden. En applikation kan föra dessa begäranden vidare till medieverktyg för att skapa separata bild- eller videoleveranser.

Tänkande är alltid aktiverat

Producentgränssnittet för K3 har alltid tänkande aktiverat. Inställningen reasoning_effort på toppnivå accepterar low, high och max, med max som standard. Dessa val är modellspecifika; en inställning utan tänkande eller ett insatsvärde från en annan familj ska inte förutsättas. Tillverkarens migrationsvägledning skiljer K3 från K2.x genom att använda reasoning_effort i stället för att föra över den äldre thinking-konfigurationen.

Producenten dokumenterar separat reasoning_content och innehåll för det slutliga svaret i strömmade resultat. För ett samtal med flera turer eller ett verktygsflöde kräver den att hela det returnerade assistentmeddelandet skickas tillbaka oförändrat, inklusive reasoning_content och tool_calls. Att bara behålla det synliga slutliga svaret förlorar information som modellens flöde med bevarat tänkande förväntar sig i nästa steg.

Strukturerade slutliga svar och partiell fortsättning

Snabbstarten dokumenterar strikt JSON-schemautdata för det slutliga meddelandeinnehållet. Definiera fälten och deras betydelser kring leveransen som applikationen behöver och tolka det slutliga innehållet i stället för att kombinera det med resonemangsfältet. Ett strukturerat resultat kan representera extraherad information från tillhandahållet material eller ett definierat rapportformat; schemat begränsar formen, medan källunderlaget avgör om värdena är korrekta.

Partiellt läge kan fortsätta ett tillhandahållet textprefix. Producentens exempel placerar ett partiellt assistentmeddelande i slutet av historiken och kombinerar prefixet med den returnerade fortsättningen för visning. Använd detta när den nödvändiga leveransen har en meningsfull fast inledning och håll prefixet skilt från den genererade återstoden.

Verktyg och kontinuitet i deras resultat

K3 stöder anpassade funktionsverktyg. Producentens exempel kräver ett verktyg i den första turen, bevarar hela assistentmeddelandet, kör varje returnerat anrop och lägger till ett matchande verktygsresultat innan det slutliga svaret begärs. Ett föreslaget anrop är inte underlag för att operationen lyckades; det faktiska returnerade resultatet blir underlaget för nästa steg.

Flödet för dynamisk laddning inför en fullständig verktygsdefinition vid en specifik punkt i meddelandehistoriken. Definitionen behöver namn, syfte och parametrar och måste finnas kvar i efterföljande historik eftersom servern inte behåller deklarationen självständigt. Håll verktygsfunktioner, tillhandahållna argument och verkliga observationer kopplade till varandra så att en lång uppgift kan fortsätta från det redan slutförda arbetet.

Utmatningskontroller och upprepad kontext

Producenten dokumenterar ett förinställt kompletteringsutrymme på 131 072 token, konfigurerbart upp till 1 048 576 inom modellens övergripande kontextbegränsningar. Dess aktuella K3 API låser temperatur till 1.0, top_p till 0.95, ett resultat och noll för närvaro- och frekvensstraff och instruerar anropare att utelämna dessa samplingskontroller. Detta är inställningar för den specifika producentvarianten, inte en överförbar lista över justerbara kontroller.

Kontextcachelagring är automatisk för berättigade upprepade prefix, med dokumenterade TTL-val på 5 minuter och 1 timme och 5 minuter som standard. Partiella cacheblock förblir cachemissar. Håll återanvändbar kontext stabil och kontrollera faktisk användning i stället för att påstå en cacheträff enbart utifrån upprepad text. För den slutliga leveransen bevarar du tillhandahållna källor, faktiskt verktygsunderlag och nödvändig utdatastruktur och kontrollerar att ett långt svar eller utvecklingsresultat uppfyller de angivna slutförandekriterierna.

Ailoot Ultra · Batchkörning POST /v1/batches moonshotai/kimi-k3:batch

moonshotai/kimi-k3:batch

MoonshotAI /moonshotai/kimi-k3:batch

Start

Godkända indata: Text
Resultat: Text

Tillgängligt i Ailoot · indata & metoder

Ailoot Ultra · Batchkörning POST /v1/batches

Indatatyper: text
Utdatatyper: text
Utdataformat: JSON i inbäddade results[].response.body

Fält	Typ	Krav	Värden & gränser	Standard
Fält`endpoint`	Typ`string`	KravObligatoriskt	Värden & gränser /v1/chat/completions	Standard—
Fält`model`	Typ`string`	KravObligatoriskt	Värden & gränser moonshotai/kimi-k3:batch	Standard—
Fält`requests`	Typ`batch_item[]`	KravObligatoriskt	Värden & gränser Minsta antal objekt: 1	Standard—
Fält`requests[].custom_id`	Typ`string`	KravObligatoriskt	Värden & gränser	Standard—
Fält`requests[].body.messages`	Typ`message[]`	KravObligatoriskt	Värden & gränser	Standard—
Fält`completion_window`	Typ`string`	KravValfritt	Värden & gränser 24h	Standard—
Fält`provider`	Typ`object\|null`	KravValfritt	Värden & gränser	Standard—
Fält`requests[].body.model`	Typ`string`	KravValfritt	Värden & gränser moonshotai/kimi-k3:batch, moonshotai/kimi-k3	Standard—
Fält`provider.only`	Typ`string[]`	KravValfritt	Värden & gränser deepinfra/bf16	Standard—
Fält`provider.allow_fallbacks`	Typ`boolean\|null`	KravValfritt	Värden & gränser false, null	Standard—

Metodparametrar och livscykel

Parameter	Avtal
Parameter`content_type`	Avtalapplication/json
Parameter`required`	Avtalendpoint, model, requests
Parameter`material_types`	Avtaltext
Parameter`representation`	AvtalInbäddade requests[]; varje objekt har custom_id och body
Parameter`request_endpoint_profile`	Avtal/v1/chat/completions
Parameter`file_material`	AvtalDen anropande klienten kan läsa in faktiska UTF-8 JSONL-data lokalt i requests[]. Inget uppladdningssyfte, input_file_id eller någon filreferens används. Om kundmaterial saknas eller är tomt avbryts förberedelserna före POST.
Parameter`serialization_order`	Avtalendpoint, model, provider (om angivet), completion_window (om angivet), requests sist
Parameter`optional_controls`	Avtalprovider.only, provider.allow_fallbacks, completion_window
Parameter`schema_scope`	AvtalFörfrågningskroppar för Text Chat Completions i det dokumenterade inbäddade Batch-formatet.

Livscykel: asynchronous

GET /v1/batches/{operation_id} · Det faktiska response.id från det ursprungliga skapandesvaret; samma användare/nyckel/grupp

Priser

Tariffuppgifter lägger inte till begäransalternativ. Parametrar som stöds anges för den valda metoden.

Snabbt läge: Ej angivet När snabbt läge är valt
Flex-läge: Ej angivet När läget flex är valt
Högsta resonemangsnivå: Ej angivet När den högsta resonemangsnivån använder standardjusteringen (default)
Prissättning för explicit cache: Inte aktiverat När explicit cache begärs

Ailoot-priser

Priser efter konfiguration

Matcha varje avgift mot de visade villkoren. Använd ett pris för varje uppsättning alternativa konfigurationer.

Konfiguration	Prislista	Kontexttoken, fler än	Kontexttoken, upp till och med	Avgift
KonfigurationGrundpriser för token	PrislistaGrundpris	Kontexttoken, fler än—	Kontexttoken, upp till och medIngen övre gräns	Avgift Indata · Indatatoken $0.00456 / 1K token Utdata · Utdatatoken $0.0228 / 1K token Indata · Cacheläsning $0.000456 / 1K token Indata · Skrivning till cache — / 1K token Indata · Skrivning till cache, 1 tim — / 1K token
KonfigurationNivå 1 för förfrågans längd	Prislista—	Kontexttoken, fler än0	Kontexttoken, upp till och medIngen övre gräns	Avgift Indata · Indatatoken $0.00456 / 1K token Utdata · Utdatatoken $0.0228 / 1K token Indata · Cacheläsning $0.000456 / 1K token Indata · Skrivning till cache — / 1K token Indata · Skrivning till cache, 1 tim — / 1K token

Ailoot reserverar ett uppskattat belopp före en begäran. Efter resultatet slutregleras avgiften utifrån uppmätt förbrukning. Slutreglering för strömning använder den slutliga förbrukningsposten. Så fungerar reservation och slutreglering →

Exempelbegäranden

Ailoot Ultra · Batchkörning

curl · bevarat referensexempelPython HTTP · kundens faktiska JSONLPython · spara varje färdigt resultat

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json
from pathlib import Path
body=json.loads('{"endpoint":"/v1/chat/completions","model":"moonshotai/kimi-k3:batch","requests":[{"custom_id":"req-0001","body":{"messages":[{"role":"user","content":"Hello!"}],"max_tokens":16}}]}')
Path("batch-request.json").write_text(json.dumps(body,ensure_ascii=False),encoding="utf-8")
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/batches \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @batch-request.json -D batch-response-headers.txt -o batch-create-response.json

import json, os
from pathlib import Path
from urllib.request import Request, urlopen

def prepare_requests(customer_path):
    path = Path(customer_path)
    if not path.is_file(): raise ValueError("Customer JSONL file is missing")
    items = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
    if not items: raise ValueError("Customer JSONL contains no requests")
    ids = set()
    for item in items:
        if set(item) != {"custom_id", "body"}: raise ValueError("Each item needs custom_id and body")
        cid = item["custom_id"]
        if not isinstance(cid, str) or not cid.strip() or cid in ids: raise ValueError("custom_id must be nonempty and unique")
        ids.add(cid)
        if not isinstance(item["body"], dict) or not item["body"].get("messages"): raise ValueError("Supply actual text messages")
        supplied_model = item["body"].get("model")
        if supplied_model is not None and supplied_model not in ['moonshotai/kimi-k3:batch', 'moonshotai/kimi-k3']: raise ValueError("body.model must be an exact documented caller or wire ID")
    return {"endpoint":"/v1/chat/completions", "model":"moonshotai/kimi-k3:batch", "requests":items}

if __name__ == "__main__":
    material = os.environ.get("AILOOT_BATCH_REQUESTS_JSONL", "")
    if not material: raise SystemExit("Set AILOOT_BATCH_REQUESTS_JSONL to your actual customer file")
    body = prepare_requests(material)
    key = os.environ.get("AILOOT_API_KEY", "")
    if not key: raise SystemExit("Set AILOOT_API_KEY")
    request = Request("https://api.ailoot.ai/v1/batches", data=json.dumps(body, ensure_ascii=False).encode("utf-8"), headers={"Authorization":"Bearer " + key, "Content-Type":"application/json"}, method="POST")
    with urlopen(request) as response:
        raw = response.read()
        Path("batch-create-response.json").write_bytes(raw)
        print(raw.decode("utf-8"))

import json
from pathlib import Path
raw = Path("batch-status-response.json").read_bytes()
response = json.loads(raw)
if response.get("status") != "completed":
    raise SystemExit("Keep the original operation; read its status without resubmitting")
results = response.get("results")
if not isinstance(results, list) or not results:
    raise SystemExit("Preserve the original response; completed results are missing")
Path("batch-results.jsonl").write_text("".join(json.dumps(item, ensure_ascii=False) + "\n" for item in results), encoding="utf-8")
# Preserve batch-status-response.json with aggregate usage and every result/error.

Ta emot och spara resultat

Ailoot Ultra · Batchkörning

JSON i inbäddade results[].response.body

GET /v1/batches/{operation_id}

Kontrollera jobbstatus

curl · status för ursprunglig åtgärd

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
BATCH_OPERATION_ID="$(python3 - <<'PY_ID'
import json
from pathlib import Path
from urllib.parse import quote
response = json.loads(Path("batch-create-response.json").read_text(encoding="utf-8"))
operation = response.get("id")
if not isinstance(operation, str) or not operation: raise SystemExit("No actual original operation ID; preserve the response and do not resubmit")
print(quote(operation, safe=""))
PY_ID
)"
curl --fail-with-body --silent --show-error "https://api.ailoot.ai/v1/batches/$BATCH_OPERATION_ID" \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o batch-status-response.json

Behåll alla färdiga resultat

Behåll varje fullständigt returnerat svar, fil och innehållsdel.

Spara hela det ursprungliga statusobjektet i JSON, varje resultat/custom_id och hela svars- eller felkroppen. Spara slutförda results[] som JSONL utan filtrering.

Om det ursprungliga svaret behöver kontrolleras

Behåll det ursprungliga operations-ID:t. Vid 503 result_pending_check gäller X-Should-Retry:false; skicka aldrig om en ursprunglig batch med okänt utfall.

Svarsfält

Fält	Typ
Fält`results[].custom_id`	Typstring
Fält`results[].response.body.choices[].message.content`	Typstring\|null
Fält`results[].error`	Typobject\|null
Fält`usage`	Typobject\|null
Fält`id`	Typstring
Fält`model`	Typstring
Fält`endpoint`	Typstring
Fält`status`	Typstring
Fält`request_counts`	Typobject
Fält`results[].id`	Typstring
Fält`results[].response.status_code`	Typinteger
Fält`results[].response.request_id`	Typstring

Fel och nästa steg

Svar	Villkor	Nästa steg
Svar400 · `invalid_request_error`	VillkorFörfrågan har ett ogiltigt inbäddat format enligt dokumentationen, duplicerade nycklar eller en felaktig objektidentitet, eller står i konflikt med modellens konfigurerade funktioner.	Nästa stegRätta de angivna fälten innan du skickar en ny förfrågan.
Svar401 · `authentication_error`	VillkorOgiltig API-nyckel.	Nästa stegAnvänd den behöriga Ailoot-nyckeln.
Svar403 · `permission_error`	VillkorGrupp för batchkörning är inte tillgänglig.	Nästa stegKontrollera nyckelns/gruppens behörighet.
Svar422 · `invalid_request_error`	VillkorBatchkörning debiteras från saldot; skapande via abonnemang avvisas.	Nästa stegAnvänd den behöriga gruppen med saldodebitering.
Svar422 · `price_unavailable`	VillkorKostnaden för batchindata kan inte beräknas i förväg.	Nästa stegSpara svaret; använd det dokumenterade indataformatet för API-familjen.
Svar402 · `billing_error`	VillkorReservation för batchkörning är inte tillgänglig.	Nästa stegSe till att villkoren för att godta förfrågan är uppfyllda innan du skickar en ny.
Svar503 · `price_unavailable`	VillkorPriset för batchmetoden eller de inbyggda priserna är inte tillgängliga.	Nästa stegSpara svaret; ersätt inte priserna med andra.
Svar503 · `api_error`	VillkorDen exakta leverantörsrutten är inte tillgänglig.	Nästa stegSpara svaret för att kunna reparera routningen.
Svar503 · `result_pending_check`	VillkorDet ursprungliga resultatet behöver kontrolleras; X-Should-Retry:false.	Nästa stegBehåll det ursprungliga värdet för operation_id/id och läs av operationens status; upprepa aldrig det ursprungliga POST-anropet.
Svar404 · `not_found`	VillkorOperationen för batchstatus saknas eller tillhör en annan identitet.	Nästa stegAnvänd exakt det ursprungliga id-värdet och samma användare/nyckel/grupp.

Alias

Modellalias

Ailoot Ultra moonshotai/kimi-k3:batch

Alias för metodsökvägar

Använd metodsökvägarna som visas ovan.

Relaterade anropar-ID:n

moonshotai/kimi-k3:batch

FAQ · MoonshotAI: Kimi K3 (batch)

Vilka indata och resultat finns?: POST /v1/batches · moonshotai/kimi-k3:batch: text → text
Vilka fält använder begäran?: POST /v1/batches · moonshotai/kimi-k3:batch: endpoint, model, requests, completion_window, provider
Vilka gränser gäller?: POST /v1/batches · moonshotai/kimi-k3:batch: requests.min_items: 1

MoonshotAI: Kimi K3 (batch)