Kimi K3 è disponibile tramite l'API Chat Completions di Moonshot AI, compatibile con OpenAI, con ID modello kimi-k3. L'API supporta ragionamento sempre attivo, streaming, immagini, video caricati, JSON Schema rigoroso, strumenti personalizzati, caricamento dinamico degli strumenti e una finestra di contesto da 1 milione di token.
Compatibilità non significa comportamento identico. K3 ha valori di campionamento fissi, richiede lo stato di assistente completo negli strumenti successivi e nei turni di conversazione e gestisce il ragionamento separatamente dal contenuto finale. Questa guida si concentra su questi dettagli.
Disponibilità e prezzi aggiornati il 22 luglio 2026. Kimi K3 è disponibile su Poyo.ai come
kimi-k3tramite l'API Chat Completions compatibile con OpenAI. Il prezzo è $2.28 per 1M token di input e $11.40 per 1M token di output — 24% inferiore al prezzo ufficiale.
Requisiti
Hai bisogno di:
- Python 3.9 o successivo;
- versione 1.0 o successiva del pacchetto Python
openaio successiva; - una chiave Moonshot API memorizzata al di fuori del controllo del codice sorgente;
- l'URL di base
https://api.moonshot.ai/v1; - codice identificativo del modello
kimi-k3.
Installa l'SDK:
python -m pip install --upgrade "openai>=1.0"
Imposta la chiave nella tua shell:
export MOONSHOT_API_KEY="your-key"
Su PowerShell:
$env:MOONSHOT_API_KEY="your-key"
Non inserire mai una chiave di produzione in un esempio di codice, bundle lato client, log o repository.
Fai la tua prima richiesta Kimi K3
Python
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["MOONSHOT_API_KEY"],
base_url="https://api.moonshot.ai/v1",
)
response = client.chat.completions.create(
model="kimi-k3",
messages=[
{"role": "user", "content": "Review this migration plan and list its three highest risks."}
],
)
print(response.choices[0].message.content)
cURL
curl https://api.moonshot.ai/v1/chat/completions \
-H "Authorization: Bearer $MOONSHOT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k3",
"messages": [
{"role": "user", "content": "Explain Kimi Delta Attention in plain language."}
]
}'
Configura lo sforzo di ragionamento
K3 utilizza sempre la modalità di pensiero. Configura il suo impegno attraverso il campo reasoning_effort di livello superiore:
response = client.chat.completions.create(
model="kimi-k3",
reasoning_effort="high",
messages=[
{"role": "user", "content": "Find the flaw in this distributed lock design."}
],
)
I valori supportati sono:
| Valore | Usalo per |
|---|---|
low | Attività più semplici in cui la latenza e l'output contano |
high | Codifica, analisi e pianificazione degli strumenti difficili |
max | I compiti più difficili e la valutazione in stile benchmark |
L'impostazione predefinita documentata è max. Non dare per scontato che sia l'impostazione di produzione più economica. Valuta il tasso di successo, la latenza e i token generati a ogni tentativo.
Ragionamento in streaming e contenuto finale
Le risposte in streaming espongono il ragionamento e il testo finale attraverso diversi campi delta.
stream = client.chat.completions.create(
model="kimi-k3",
messages=[{"role": "user", "content": "Review this architecture for race conditions."}],
stream=True,
)
for chunk in stream:
delta = chunk.choices[0].delta
reasoning = getattr(delta, "reasoning_content", None)
if reasoning:
# Store or process according to your product and provider policies.
pass
if delta.content:
print(delta.content, end="", flush=True)
Mantieni i contenuti finali rivolti agli utenti separati dall'elaborazione interna. Non analizzare l'output strutturato da reasoning_content.
Invia un'immagine a Kimi K3
I messaggi di visione K3 utilizzano una serie di oggetti di contenuto. Gli URL di immagini pubbliche non sono supportati in questo flusso; codificare un'immagine locale come base64.
import base64
from pathlib import Path
image_data = base64.b64encode(Path("interface.png").read_bytes()).decode()
response = client.chat.completions.create(
model="kimi-k3",
messages=[
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{image_data}"},
},
{
"type": "text",
"text": "Identify the three largest accessibility problems in this interface.",
},
],
}
],
)
Convalida il tipo e le dimensioni del file prima di codificare i caricamenti degli utenti. Evita di registrare i payload Base64.
Invia un video a Kimi K3
Carica il video tramite i file API, fai riferimento all'ID restituito con lo schema ms:// ed elimina il file quando non è più necessario.
from pathlib import Path
video = client.files.create(file=Path("demo.mp4"), purpose="video")
try:
response = client.chat.completions.create(
model="kimi-k3",
messages=[
{
"role": "user",
"content": [
{
"type": "video_url",
"video_url": {"url": f"ms://{video.id}"},
},
{"type": "text", "text": "Summarize the workflow and identify failed steps."},
],
}
],
)
finally:
client.files.delete(video.id)
Restituisci un output conforme a uno schema JSON rigoroso
Utilizza strict: true quando il codice downstream necessita di una forma prevedibile.
import json
response = client.chat.completions.create(
model="kimi-k3",
messages=[
{"role": "user", "content": "Extract the risk, severity, and owner from this incident note."}
],
response_format={
"type": "json_schema",
"json_schema": {
"name": "incident_risk",
"strict": True,
"schema": {
"type": "object",
"properties": {
"risk": {"type": "string"},
"severity": {"type": "string", "enum": ["low", "medium", "high"]},
"owner": {"type": ["string", "null"]},
},
"required": ["risk", "severity", "owner"],
"additionalProperties": False,
},
},
},
)
result = json.loads(response.choices[0].message.content or "{}")
Analizza solo lo message.content finale, quindi convalidarlo nuovamente nel codice dell'applicazione.
Richiama strumenti personalizzati
La prima risposta può richiedere uno o più strumenti. Esegui ciascuna chiamata consentita, aggiungi il messaggio completo dell'assistente, quindi aggiungi un risultato dello strumento corrispondente per ogni tool_call_id.
import json
tools = [
{
"type": "function",
"function": {
"name": "get_build_status",
"description": "Return the current build status for an allowed project.",
"parameters": {
"type": "object",
"properties": {"project": {"type": "string"}},
"required": ["project"],
"additionalProperties": False,
},
},
}
]
messages = [{"role": "user", "content": "Check the web build and summarize any failure."}]
first = client.chat.completions.create(
model="kimi-k3",
messages=messages,
tools=tools,
tool_choice="required",
)
assistant_message = first.choices[0].message
messages.append(assistant_message)
for call in assistant_message.tool_calls or []:
arguments = json.loads(call.function.arguments)
# Authorize and validate before executing a real tool.
tool_result = {"project": arguments["project"], "status": "passed"}
messages.append(
{
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(tool_result),
}
)
final = client.chat.completions.create(
model="kimi-k3",
messages=messages,
tools=tools,
)
Non eseguire mai comandi shell arbitrari generati dal modello senza un limite di autorizzazione, una convalida dell'input, un ambiente con ambito e un audit trail.
Carica gli strumenti in modo dinamico
K3 supporta l'inserimento di una definizione dello strumento completa in un messaggio system nel momento in cui diventa disponibile. Conserva quel messaggio nella cronologia successiva perché il server non lo conserva per te.
Il caricamento dinamico aiuta i sistemi agentici di grandi dimensioni a evitare di inviare ogni schema di strumento a ogni turno. Crea inoltre nuovi requisiti di gestione dello stato: il modello deve vedere la dichiarazione esatta quando interpreta i risultati successivi dello strumento.
Utilizza la finestra di contesto da 1M token
I contesti ampi sono più preziosi quando è necessario ragionare insieme su prove distanti. Usali deliberatamente:
- Mantieni repository stabili o corpora di documenti all'inizio.
- Aggiungi domande e risultati anziché riscrivere il prefisso.
- Tieni traccia separatamente degli input memorizzati nella cache e non nella cache.
- Recupera un sottoinsieme più piccolo quando l'intero corpus non è necessario.
- Stabilisci gli identificatori della fonte in modo che la risposta finale possa essere verificata.
- Compatta solo quando il tuo client conserva tutto lo stato richiesto da K3.
La memorizzazione nella cache automatica non ha ID cache o parametri TTL ordinari. I prefissi stabili offrono al servizio la migliore opportunità di raggiungere la cache.
Conserva lo stato multigiro completo
Questa è la regola di integrazione più importante specifica per K3.
Quando si continua una conversazione o si restituiscono i risultati dello strumento, aggiungi il messaggio completo dell'assistente restituito da API. Non conservare solo content. Moonshot avverte che K3 è stato addestrato con la storia del pensiero conservata e può diventare instabile se il framework dell'agente perde la cronologia richiesta o passa a K3 nel bel mezzo di una sessione.
Archivia lo stato della conversazione in modo sicuro, applica limiti di conservazione ed evita di esporre lo stato nascosto agli utenti che non dovrebbero vederlo.
Limiti importanti Kimi K3 API
- K3 ha sempre il pensiero abilitato.
reasoning_effortsupportalow,highemax.max_completion_tokenspredefinito è 131,072 e può essere impostato su 1,048,576.temperature=1.0,top_p=0.95,n=1,presence_penalty=0efrequency_penalty=0sono fissi; ometteteli.- Gli URL di immagini pubbliche non sono supportati per i messaggi di visione.
- Le richieste multigiro e con strumenti devono preservare il messaggio completo dell'assistente.
- Moonshot afferma che il suo strumento di ricerca web è in fase di aggiornamento e non è attualmente consigliato per la produzione.
Lista di controllo della produzione
- Mantieni le chiavi API lato server.
- Aggiungi timeout delle richieste e tentativi limitati.
- Convalida gli argomenti dello strumento e autorizza ogni azione.
- Limita i turni di utilizzo degli strumenti e la lunghezza di completamento.
- Conserva lo stato completo dell'assistente K3.
- Convalida rigorosamente il JSON dopo la generazione.
- Registra input, input memorizzati nella cache, output, latenza ed errori.
- Evita di cambiare modello nel mezzo di una sessione K3.
- Aggiungi limiti comportamentali espliciti per ridurre un'eccessiva proattività.
- Esegui test con strumenti non funzionanti, risposte parziali e storie lunghe.
Leggi Prezzi Kimi K3 API prima di scegliere il contesto e i limiti di output. Segui la pagina del modello Kimi K3 per la disponibilità di Poyo.ai.
Domande frequenti
L'API Kimi K3 è compatibile con OpenAI?
Sì. Moonshot espone un endpoint di completamento chat compatibile con OpenAI. Si applicano ancora le regole relative allo stato, al ragionamento, al campionamento e ai media specifiche di K3.
Qual è l'ID del modello Kimi K3?
L'ID modello ufficiale Moonshot API è kimi-k3.
Kimi K3 supporta la chiamata di funzioni?
Sì. Supporta strumenti personalizzati, scelta dello strumento richiesto, risultati dello strumento corrispondente e caricamento dinamico dello strumento.
Kimi K3 è in grado di elaborare video?
Sì. Carica il video tramite i file API e fai riferimento al relativo ID file ms:// in un oggetto contenuto video.
Come si utilizza la finestra di contesto 1M?
Invia i messaggi e i contenuti richiesti tramite la richiesta del modello standard, mantieni invariati i prefissi stabili per la memorizzazione nella cache automatica e imposta limiti di completamento limitati.