MoonshotAI: Kimi K3 (batch)

Kimi K3 est le modèle de raisonnement nativement multimodal de Moonshot AI pour les longues tâches de programmation et le travail de connaissance. Il lit texte, images et vidéo, produit du texte et prend en charge des processus avec outils dans un contexte de 1 048 576 tokens, en conservant l’historique de réflexion entre étapes.

Ailoot Ultra · Traitement par lots POST /v1/batches moonshotai/kimi-k3:batch

À propos du modèle

Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.

Kimi K3 est le modèle d’agent multimodal à poids ouverts de Moonshot AI pour la programmation prolongée, le travail de connaissance et le raisonnement. Il associe texte et compréhension visuelle native des images et vidéos et produit une réponse textuelle ou une demande d’outil. Le fabricant met en avant les sessions d’ingénierie étendues, les grands dépôts et les tâches combinant captures ou retours visuels avec le code. Une consigne utile définit le livrable souhaité, les éléments à utiliser et la condition d’achèvement.

Architecture et contexte long

La fiche décrit un mélange clairsemé d’experts de 2 800 milliards de paramètres au total, dont 104 milliards activés. Sa conception Stable LatentMoE sélectionne 16 experts sur 896 par token et utilise Kimi Delta Attention et Attention Residuals avec une attention à portes. La longueur exacte de contexte est de 1 048 576 tokens. Cet espace accueille un dossier important ; il ne justifie pas l’abandon des frontières entre sources ou de la place nécessaire au résultat.

L’artefact natif publié utilise un entraînement tenant compte de la quantification, avec des poids MXFP4 et des activations MXFP8. C’est le format de publication du fabricant, distinct d’une édition quantifiée séparée ou d’une affirmation sur la manière dont une route particulière sert le modèle. Les poids ouverts et un grand nombre de paramètres ne font pas du nombre actif une mesure du stockage total ou du matériel nécessaire.

Préparer une tâche substantielle de programmation

Fournissez les ressources pertinentes du dépôt, le comportement existant, le changement demandé et les contraintes de compatibilité. Identifiez les fichiers ou l’interface visés, les vérifications déterminant la réussite et toute erreur ou entrée révélant le problème. Un résultat utile peut être une modification ciblée avec une explication et les résultats de vérifications réellement exécutées, plutôt qu’une description d’actions jamais réalisées.

Pour du développement visuel, incluez une capture ou une vue claire du résultat attendu avec le code pertinent et un écart précis. Le concepteur décrit des processus d’interfaces web, de jeux et de CAO utilisant le retour visuel. Demandez la modification reliant le code au résultat observé et conservez la référence pour vérifier le livrable.

Préparer images, vidéos et travail de connaissance

Le démarrage rapide du producteur utilise des objets de contenu typés pour les messages visuels ; content est un tableau, pas une représentation sérialisée de celui-ci. Le processus image utilise des données encodées ou une référence de fichier prise en charge plutôt qu’une adresse publique d’image. L’exemple vidéo téléverse un fichier et fournit sa référence avec une question sur son contenu. Donnez une source lisible et précisez l’observation, l’intervalle ou la relation importante. Le processus visuel accepte les images JPEG, PNG, GIF, WebP, BMP, HEIC et HEIF et les vidéos MP4, MPEG, MOV, AVI, FLV, MPG, WebM, WMV et 3GPP. Un GIF ou WebP animé peut être décodé comme vidéo. Fournissez la source SVG sous forme de texte. Le concepteur recommande des images jusqu’à 4 096 × 2 160 et des vidéos jusqu’à 1 920 × 1 080 ; ce sont des recommandations de résolution, pas des seuils de rejet. Gardez le corps de requête dans la limite documentée de 100M et téléversez comme fichiers les médias volumineux ou réutilisés.

Pour une recherche riche en documents, identifiez les sources et les questions auxquelles le rapport final doit répondre. Pour expliquer une vidéo, indiquez les événements ou la séquence à analyser plutôt que de demander des commentaires sans limites. K3 utilise le contenu visuel comme éléments de raisonnement et renvoie du texte ou des demandes d’outils. L’application peut transmettre ces demandes à des outils média pour créer des livrables image ou vidéo séparés.

Réflexion toujours activée

L’interface K3 du producteur active toujours la réflexion. Le réglage de premier niveau reasoning_effort accepte low, high et max, avec max par défaut. Ces choix sont propres au modèle ; il ne faut supposer ni réglage sans réflexion ni valeur d’effort empruntée à une autre famille. Le guide de migration distingue K3 de K2.x en utilisant reasoning_effort plutôt que l’ancienne configuration thinking.

Le producteur documente des champs séparés reasoning_content et contenu de réponse finale dans les résultats diffusés en continu. Pour une conversation à plusieurs tours ou avec outils, il exige de renvoyer le message complet de l’assistant inchangé, y compris reasoning_content et tool_calls. Ne conserver que la réponse finale visible perd les informations attendues à l’étape suivante par le processus de réflexion conservée.

Réponses finales structurées et continuation partielle

Le démarrage rapide documente une sortie stricte par schéma JSON pour le contenu du message final. Définissez champs et significations autour du livrable nécessaire à l’application et analysez ce contenu final plutôt que de le combiner au champ de raisonnement. Un résultat structuré peut représenter des informations extraites ou un format de rapport défini ; le schéma contraint sa forme, tandis que les sources déterminent la justesse des valeurs.

Le mode partiel poursuit un préfixe textuel fourni. L’exemple place un message partiel d’assistant à la fin de l’historique et combine ce préfixe avec la continuation renvoyée pour l’affichage. Utilisez-le lorsque le livrable possède un début fixe pertinent, en distinguant ce préfixe du reste généré.

Outils et continuité des résultats

K3 prend en charge les outils de fonctions personnalisés. L’exemple exige un outil au premier tour, préserve le message complet de l’assistant, exécute chaque appel renvoyé et ajoute le résultat d’outil correspondant avant de demander la réponse finale. Un appel proposé ne prouve pas la réussite de l’opération ; le résultat réel devient l’élément justificatif de l’étape suivante.

Le processus de chargement dynamique introduit une définition complète d’outil à un point précis de l’historique. Elle nécessite nom, finalité et paramètres et doit rester dans l’historique suivant, car le serveur ne conserve pas cette déclaration indépendamment. Associez capacités d’outils, arguments fournis et observations réelles pour poursuivre une longue tâche depuis le travail déjà achevé.

Contrôles de sortie et contexte répété

Le producteur documente une allocation de complétion par défaut de 131 072 tokens, configurable jusqu’à 1 048 576 dans les contraintes globales de contexte. Son API K3 actuelle fixe temperature à 1.0, top_p à 0.95, un seul résultat et des pénalités de présence et de fréquence à zéro, et demande d’omettre ces contrôles d’échantillonnage. Ce sont les réglages du profil exact du producteur, pas une liste transférable de contrôles ajustables.

La mise en cache du contexte est automatique pour les préfixes répétés admissibles, avec des durées de validité documentées de 5 minutes ou 1 heure et 5 minutes par défaut. Les blocs de cache partiels restent des absences de cache. Gardez le contexte réutilisable stable et vérifiez l’usage réel plutôt que d’affirmer un succès de cache sur la seule répétition de texte. Pour le livrable final, conservez les sources fournies, les résultats réels des outils et la structure requise, puis vérifiez que la longue réponse ou le résultat d’ingénierie respecte les critères d’achèvement.

Ailoot Ultra · Traitement par lots POST /v1/batches moonshotai/kimi-k3:batch

moonshotai/kimi-k3:batch

MoonshotAI /moonshotai/kimi-k3:batch

Premiers pas

Entrées acceptées: Texte
Résultats: Texte

Disponible dans Ailoot · entrées et méthodes

Ailoot Ultra · Traitement par lots POST /v1/batches

Entrée: text
Sortie: text
Format de sortie: JSON results[].response.body intégré

Champ	Type	Exigence	Valeurs et limites	Par défaut
Champ`endpoint`	Type`string`	ExigenceObligatoire	Valeurs et limites /v1/chat/completions	Par défaut—
Champ`model`	Type`string`	ExigenceObligatoire	Valeurs et limites moonshotai/kimi-k3:batch	Par défaut—
Champ`requests`	Type`batch_item[]`	ExigenceObligatoire	Valeurs et limites Nombre minimal d’éléments: 1	Par défaut—
Champ`requests[].custom_id`	Type`string`	ExigenceObligatoire	Valeurs et limites	Par défaut—
Champ`requests[].body.messages`	Type`message[]`	ExigenceObligatoire	Valeurs et limites	Par défaut—
Champ`completion_window`	Type`string`	ExigenceFacultatif	Valeurs et limites 24h	Par défaut—
Champ`provider`	Type`object\|null`	ExigenceFacultatif	Valeurs et limites	Par défaut—
Champ`requests[].body.model`	Type`string`	ExigenceFacultatif	Valeurs et limites moonshotai/kimi-k3:batch, moonshotai/kimi-k3	Par défaut—
Champ`provider.only`	Type`string[]`	ExigenceFacultatif	Valeurs et limites deepinfra/bf16	Par défaut—
Champ`provider.allow_fallbacks`	Type`boolean\|null`	ExigenceFacultatif	Valeurs et limites false, null	Par défaut—

Paramètres et cycle de vie de la méthode

Paramètre	Contrat
Paramètre`content_type`	Contratapplication/json
Paramètre`required`	Contratendpoint, model, requests
Paramètre`material_types`	Contrattext
Paramètre`representation`	Contratrequests[] intégré ; chaque élément comporte custom_id et body
Paramètre`request_endpoint_profile`	Contrat/v1/chat/completions
Paramètre`file_material`	ContratL’appelant peut charger localement le contenu JSONL UTF-8 effectif dans requests[]. Aucun paramètre purpose de téléversement, input_file_id ni référence à un fichier n’est utilisé. Si les données du client sont absentes ou vides, la préparation s’arrête avant le POST.
Paramètre`serialization_order`	Contratendpoint, model, provider (si fourni), completion_window (si fourni), requests en dernier
Paramètre`optional_controls`	Contratprovider.only, provider.allow_fallbacks, completion_window
Paramètre`schema_scope`	ContratCorps de requêtes Chat Completions textuelles dans l’enveloppe Batch intégrée documentée.

Cycle de vie : asynchronous

GET /v1/batches/{operation_id} · response.id effectivement renvoyé lors de la création d’origine ; même utilisateur, même clé et même groupe

Tarifs

Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.

Mode rapide: Non précisé Lorsque le mode rapide est sélectionné
Mode Flex: Non précisé Lorsque le mode flex est sélectionné
Effort de raisonnement maximal: Non précisé Lorsque l’effort de raisonnement maximal utilise l’ajustement par défaut (default)
Tarification du cache explicite: Non activé Lorsqu’un cache explicite est demandé

Tarifs Ailoot

Prix par configuration

Associez chaque coût aux conditions indiquées. Utilisez un seul tarif pour chaque ensemble de configurations alternatives.

Configuration	Barème tarifaire	Tokens de contexte, plus de	Tokens de contexte, jusqu’à la limite incluse	Coût
ConfigurationTarifs de base des tokens	Barème tarifaireTarif de base	Tokens de contexte, plus de—	Tokens de contexte, jusqu’à la limite incluseSans borne supérieure	Coût Entrée · Tokens en entrée $0.00456 / 1K tokens Sortie · Tokens en sortie $0.0228 / 1K tokens Entrée · Lecture du cache $0.000456 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens
ConfigurationPalier 1 de longueur de requête	Barème tarifaire—	Tokens de contexte, plus de0	Tokens de contexte, jusqu’à la limite incluseSans borne supérieure	Coût Entrée · Tokens en entrée $0.00456 / 1K tokens Sortie · Tokens en sortie $0.0228 / 1K tokens Entrée · Lecture du cache $0.000456 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens

Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →

Exemples de requêtes

Ailoot Ultra · Traitement par lots

curl · jeu de données de référence conservéPython HTTP · données JSONL réelles du clientPython · enregistrer chaque résultat finalisé

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.

Recevoir et enregistrer les résultats

Ailoot Ultra · Traitement par lots

JSON results[].response.body intégré

GET /v1/batches/{operation_id}

Vérifier l’état de la tâche

curl · état de l’opération d’origine

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

Conserver tous les résultats terminés

Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.

Conservez l’intégralité du JSON de statut d’origine, chaque résultat/custom_id et le corps complet de la réponse ou de l’erreur. Enregistrez les results[] terminés au format JSONL sans filtrage.

Si la réponse d’origine doit être vérifiée

Conservez l’identifiant de l’opération d’origine. La réponse 503 result_pending_check contient X-Should-Retry:false ; ne soumettez jamais à nouveau un lot d’origine dont l’issue est inconnue.

Champs de la réponse

Champ	Type
Champ`results[].custom_id`	Typestring
Champ`results[].response.body.choices[].message.content`	Typestring\|null
Champ`results[].error`	Typeobject\|null
Champ`usage`	Typeobject\|null
Champ`id`	Typestring
Champ`model`	Typestring
Champ`endpoint`	Typestring
Champ`status`	Typestring
Champ`request_counts`	Typeobject
Champ`results[].id`	Typestring
Champ`results[].response.status_code`	Typeinteger
Champ`results[].response.request_id`	Typestring

Erreurs et étapes suivantes

Réponse	Condition	Étape suivante
Réponse400 · `invalid_request_error`	ConditionEnveloppe intégrée documentée invalide, clés dupliquées, identité d’élément incorrecte ou conflit avec les capacités configurées du modèle.	Étape suivanteCorrigez les champs indiqués avant toute nouvelle soumission.
Réponse401 · `authentication_error`	ConditionClé API invalide.	Étape suivanteUtilisez la clé Ailoot autorisée.
Réponse403 · `permission_error`	ConditionGroupe de traitement par lots indisponible.	Étape suivanteVérifiez les droits d’accès de la clé/du groupe.
Réponse422 · `invalid_request_error`	ConditionLe traitement par lots est facturé sur le solde ; la création via un abonnement est refusée.	Étape suivanteUtilisez le groupe autorisé dont la facturation est prélevée sur le solde.
Réponse422 · `price_unavailable`	ConditionImpossible d’établir un devis pour les données d’entrée du traitement par lots.	Étape suivanteConservez la réponse ; utilisez les données d’entrée documentées pour cette famille.
Réponse402 · `billing_error`	ConditionRéserve pour le traitement par lots indisponible.	Étape suivanteRéglez les conditions d’admission avant une nouvelle requête.
Réponse503 · `price_unavailable`	ConditionPrix de la méthode Batch/tarifs natifs indisponibles.	Étape suivanteConservez la réponse ; ne substituez pas d’autres prix.
Réponse503 · `api_error`	ConditionRoute exacte du fournisseur indisponible.	Étape suivanteConservez la réponse pour réparer la route.
Réponse503 · `result_pending_check`	ConditionLe résultat d’origine nécessite une vérification ; X-Should-Retry:false.	Étape suivanteConservez l’operation_id/id d’origine et consultez son statut ; ne répétez jamais le POST d’origine.
Réponse404 · `not_found`	ConditionOpération de suivi du traitement par lots absente ou appartenant à une autre identité.	Étape suivanteUtilisez l’id exact d’origine avec le même utilisateur, la même clé et le même groupe.

Alias

Alias du modèle

Ailoot Ultra moonshotai/kimi-k3:batch

Alias des chemins de méthode

Utilisez les chemins de méthode indiqués ci-dessus.

ID d’appel associés

moonshotai/kimi-k3:batch

FAQ · MoonshotAI: Kimi K3 (batch)

Quelles entrées et quels résultats sont disponibles ?: POST /v1/batches · moonshotai/kimi-k3:batch: text → text
Quels champs la requête utilise-t-elle ?: POST /v1/batches · moonshotai/kimi-k3:batch: endpoint, model, requests, completion_window, provider
Quelles limites s’appliquent ?: POST /v1/batches · moonshotai/kimi-k3:batch: requests.min_items: 1

MoonshotAI: Kimi K3 (batch)