Kimi K3: Fitur, Tolok Ukur, API, dan 5 Contoh Praktis

Persaingan model open kembali bergerak pada 16 Juli 2026, ketika Moonshot AI merilis Kimi K3, model dengan 2,8 triliun parameter, jendela konteks 1 juta token, dan vision bawaan. Ini adalah model open terbesar yang pernah dirilis Moonshot, jauh melampaui Kimi K2 dari sisi ukuran, dan yang pertama mereka sebut mencapai kelas 3 triliun parameter.

Jika Anda mencari kisah peluncuran, ulasan mendalam arsitektur, grafik tolok ukur, perbandingan dengan Claude, GPT, dan lab-lab Tiongkok lainnya, serta daftar keterbatasan dari Moonshot sendiri, artikel blog Kimi K3 kami membahas semuanya. Tutorial ini adalah sisi praktisnya, termasuk cara mengaksesnya dan perilakunya saat digunakan. Saya akan membahas lima contoh kecil, empat melalui API, di mana saya menunjukkan penggunaan token dan biaya nyata, serta dua di aplikasi web kimi.com. Bersama-sama, ini mencakup bagaimana K3 menangani:

• Memanggil tool dan mengembalikan JSON ketat
• Memuat definisi tool secara dinamis
• Memangkas biaya konteks panjang dengan caching otomatis
• Membaca tangkapan layar dan memperbaiki tata letak
• Membangun dasbor interaktif dari satu prompt

Keempat contoh API dijalankan pada 17 Juli 2026 terhadap model kimi-k3, dan biayanya sekitar 11 sen pada run dingin, atau beberapa sen setelah caching aktif.

Cara Mengakses Kimi K3

Cara tercepat untuk mencoba model ini adalah kimi.com, di mana aplikasi web dan aplikasi seluler menjalankan Kimi K3 untuk tugas agen umum tanpa perlu pengaturan.

Untuk pekerjaan yang lebih berat seperti laporan dan dasbor, ada Kimi Work, aplikasi desktop.

Jika Anda hidup di terminal, Kimi Code adalah agen coding yang Anda pasang dari npm sebagai @moonshot-ai/kimi-code, dan Anda memilih modelnya di sana dengan perintah /model. Menggunakan K3 di Kimi Code memerlukan keanggotaan berbayar, dan jendela 1 juta token penuh memerlukan tier yang lebih tinggi.

Tutorial ini berfokus pada API mentah dan aplikasi web, tetapi agen terminal tersedia jika Anda membutuhkannya.

Namun, K3 tidak menggantikan saudaranya. Tabel di bawah menunjukkan bagaimana jajaran saat ini dibagi.

Ringkasnya, K3 adalah model awal yang tepat ketika suatu pekerjaan memadukan kode, tool, dokumen, dan gambar, atau ketika Anda benar-benar membutuhkan jendela 1 juta token. Untuk pembuatan kode murni di mana kecepatan lebih penting daripada konteks, kimi-k2.7-code masih merupakan pilihan yang lebih masuk akal, jadi jangan berasumsi model terbaru selalu yang paling tepat.

Menyiapkan API Kimi K3

API ini kompatibel dengan SDK OpenAI, jadi jika Anda pernah menggunakannya sebelumnya, hampir tidak ada yang baru di sini. Anda memerlukan Python 3.9 atau yang lebih baru dan sebuah kunci API.

Langkah 1: Membuat kunci API

Pertama, masuk ke platform Kimi dan buka halaman API Keys di konsol. Buat sebuah kunci, salin sekali, dan simpan di tempat yang aman, karena Anda tidak akan melihatnya lagi. Anda juga memerlukan saldo kecil di akun untuk melakukan pemanggilan, dan untuk seluruh tutorial ini beberapa dolar sudah cukup.

Membuat kunci API Kimi K3. Gambar oleh Penulis.

Langkah 2: Menginstal SDK

Selanjutnya, instal SDK OpenAI ke lingkungan Anda. Satu perintah saja sudah cukup.

python -m pip install --upgrade "openai>=1.0"

Itu akan menarik library klien yang digunakan oleh contoh-contoh berikut, dan tidak ada yang khusus Kimi untuk diinstal.

Langkah 3: Menyimpan kunci dan menginisialisasi klien

Lebih baik membaca kunci dari sebuah variabel lingkungan daripada menempelkannya ke dalam kode Anda. Setel MOONSHOT_API_KEY di shell Anda atau di berkas .env , lalu arahkan klien ke base URL Moonshot.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

Hanya dua hal yang berbeda dari penyiapan OpenAI standar, yaitu base_url dan nama model, yaitu kimi-k3. Dengan itu, Anda siap melakukan panggilan.

Langkah 4: Melakukan panggilan pertama

Sekarang untuk permintaan pertama. Saya meminta model untuk memperkenalkan dirinya, yang berujung pada momen kecil yang jujur.

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Introduce Kimi K3 in one sentence."}],
    max_completion_tokens=800,
)
print(completion.choices[0].message.content)

Balasannya adalah penolakan sopan untuk menebak: model mengatakan tidak memiliki informasi andal tentang Kimi K3, karena dilatih sebelum perilisannya sendiri, dan mengarahkan saya ke pengumuman Moonshot. Itu pengingat berguna bahwa model tidak mengetahui dirinya sendiri. Panggilan API yang saya lakukan barusan biayanya sekitar tujuh persepuluh sen. Perhatikan batas max_completion_tokens yang saya tetapkan pada setiap panggilan di tutorial ini untuk mencegah keluaran yang panjang menaikkan tagihan.

Keluaran panggilan API pertama Kimi K3. Gambar oleh Penulis.

Contoh 1: Streaming Penalaran dan Jawaban Akhir

K3 selalu melakukan penalaran, dan API mengembalikan penalaran itu pada saluran terpisah dari jawabannya. Saat Anda melakukan streaming, setiap potongan dapat membawa reasoning_content, content akhir, atau keduanya, sehingga Anda dapat menempatkan proses berpikir dan jawaban secara terpisah.

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much is the ball?"}],
    max_completion_tokens=1200,
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        print(reasoning, end="", flush=True)
    if delta.content:
        print(delta.content, end="", flush=True)

Model ini men-stream cara kerjanya terlebih dahulu: ia mengenali soal pemukul-dan-bola sebagai Tes Refleksi Kognitif klasik, menandai jawaban intuitif yang salah $0,10, lalu mengerjakan aljabarnya hingga bola berharga $0,05 dan memeriksa bahwa $1,05 ditambah $0,05 menjadi $1,10. Pemisahan inilah yang berguna: dalam aplikasi nyata Anda menampilkan content ke pengguna dan menyimpan reasoning_content untuk log, karena menampilkan penalaran mentah di produksi jarang menjadi pilihan. Panggilan ini menggunakan 488 token keluaran dan biayanya di bawah satu sen.

Men-stream penalaran lalu jawaban akhir. Gambar oleh Penulis.

Contoh 2: Pemanggilan Tool dengan Output Terstruktur

Kimi K3 adalah model dalam lini produk yang mendukung tool_choice="required", yang memaksa setidaknya satu pemanggilan tool pada sebuah giliran. Ini berguna saat Anda ingin model mengambil data sebelum menjawab alih-alih menebak. Di sini saya memberinya dua tool tiruan, pencarian harga dan pemeriksaan stok, memaksa pemanggilan tool, menjalankan tool secara lokal, lalu meminta hasilnya sebagai JSON ketat menggunakan response_format.

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=TOOLS,
    tool_choice="required",
    max_completion_tokens=2500,
)
assistant_message = first.choices[0].message
messages.append(assistant_message)

for tool_call in assistant_message.tool_calls or []:
    args = json.loads(tool_call.function.arguments)
    messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": run_tool(tool_call.function.name, args)})

Model memanggil kedua tool dengan kode produk yang benar, lalu mengembalikan ringkasan pesanan yang bersih sebagai JSON: lima keyboard mekanis seharga $89 masing-masing, total $445, dan penanda stok bernilai true. Dua detail membuat ini berfungsi dalam praktik. Anda harus menambahkan kembali pesan asisten lengkap ke percakapan sebelum menambahkan hasil tool, dan Anda sebaiknya hanya mengurai content untuk JSON, jangan pernah bidang penalaran. Sepasang panggilan ini biayanya kurang dari satu sen digabungkan.

Pemanggilan tool dan output JSON terstruktur. Gambar oleh Penulis.

Contoh 3: Memuat Tool Secara Dinamis

Jika Anda memiliki lusinan tool, mengirim semua definisinya pada setiap permintaan akan memboroskan token dan mengotori prompt. Kimi K3 memungkinkan Anda menyuntikkan definisi tool di tengah percakapan dengan pesan system yang membawa bidang tools dan tanpa content. Tool tersebut menjadi tersedia mulai saat itu, yang membuat katalog tool besar tetap berada di prefix cache Anda sampai sebuah tool benar-benar diperlukan.

messages = [
    {"role": "user", "content": "Convert 100 US dollars to euros at a rate of 0.92."},
    {"role": "system", "tools": [{
        "type": "function",
        "function": {
            "name": "convert_currency",
            "description": "Convert an amount from one currency to another",
            "parameters": {
                "type": "object",
                "properties": {"amount": {"type": "number"}, "rate": {"type": "number"}},
                "required": ["amount", "rate"],
            },
        },
    }]},
]
completion = client.chat.completions.create(model="kimi-k3", messages=messages)
print(completion.choices[0].message.tool_calls)

K3 mengenali tool yang baru dimuat dan memanggil convert_currency dengan amount 100 dan rate 0,92, persis seperti yang dimaksud. Satu hal yang perlu diingat adalah server tidak menyimpan definisi ini untuk Anda, jadi Anda mengirim ulang pesan system pada permintaan berikutnya jika ingin tool tetap tersedia. Ini adalah panggilan termurah dalam set, sekitar dua persepuluh sen.

Memanggil tool konversi mata uang yang dimuat secara dinamis. Gambar oleh Penulis.

Contoh 4: Memangkas Biaya Konteks Panjang dengan Caching

Contoh ini adalah saat jendela 1 juta token menjadi praktis. Caching konteks bersifat otomatis, tanpa ID cache dan tanpa time-to-live yang perlu dikelola. Anda mengirim prefix besar, menjaganya identik byte demi byte pada permintaan berikutnya, dan bagian yang berulang ditagihkan pada tarif cache-hit alih-alih cache-miss. Untuk membuat perbedaannya terlihat, saya menggunakan basis pengetahuan sekitar 33.000 token dan mengajukan pertanyaan tentangnya.

knowledge = Path("knowledge_base.md").read_text(encoding="utf-8")
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": knowledge},
        {"role": "user", "content": "What is the rated payload of the Atlas robot?"},
    ],
    max_completion_tokens=600,
)

Pertama kali saya mengirim prefix itu, tidak ada yang tercache, dan permintaan biayanya sekitar 9,9 sen untuk kira-kira 33.000 token input. Setelah prefix tersebut pernah dilihat, permintaan yang sama mengenai cache pada semua 32.512 token prefix dan biayanya sekitar 1,1 sen, mendekati penurunan sembilan kali lipat. Alasannya adalah kesenjangan harga: input yang tercache adalah $0,30 per sejuta token dibanding $3,00 untuk yang tidak tercache. Satu keanehan yang saya temui adalah penulisan cache bersifat asinkron, jadi hit tidak muncul pada panggilan langsung berikutnya. Ia muncul pada permintaan selanjutnya, jadi menjalankan skrip dua kali dengan jeda satu menit akan menunjukkan miss lalu hit.

Biaya cache miss versus cache hit. Gambar oleh Penulis.

Contoh 5: Menemukan Bug Tata Letak di Tangkapan Layar

Vision adalah fitur bawaan K3, dan API adalah cara yang bersih untuk menggunakannya, meski tidak menerima URL gambar publik. Anda mengirim gambar sebagai data URL base64 dan menjadikan content pesan sebagai array objek, satu bagian untuk gambar dan satu untuk teks. Saya merender dasbor kecil dengan beberapa bug tata letak yang disengaja, menyimpan tangkapan layar, dan menanyakan ke K3 apa yang salah.

Dasbor dengan bug tata letak yang disengaja. Gambar oleh Penulis.

import base64
from pathlib import Path

image_data = base64.b64encode(Path("broken_dashboard.png").read_bytes()).decode()
completion = 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": "List the layout and alignment problems you can see, and give a short CSS fix for each."},
        ],
    }],
    max_completion_tokens=3500,
)
print(completion.choices[0].message.content)

K3 membaca gambar dengan baik. Ia menangkap kartu yang posisinya lebih rendah dari baris dan tumpang tindih dengan tetangganya, lencana yang bertengger di atas angka (bahkan salah membaca 3.910 yang tertutup sebagai 5.910, yang justru membuktikan bug tersebut), celah yang tidak rata sebelum kartu terakhir, batang yang menembus ke kartu di atas, dan tooltip yang berada di atas batang, serta memberikan perbaikan CSS singkat untuk masing-masing, seperti memindahkan kartu ke satu grid. Namun, ia melewatkan subtitle berkontras rendah yang hampir tak terlihat, jadi vision lebih menangkap hal mencolok di mata daripada detail yang samar. Panggilan ini biayanya sekitar dua sen.

Keterbatasan Kimi K3

Contoh-contoh API berjalan baik, tetapi beberapa sisi kasar patut disebut agar Anda tidak terkejut. Saya mengalami sebagian besar ini secara langsung.

• Hanya reasoning_effort="max" yang tersedia untuk saat ini, jadi Anda belum bisa menurunkan tingkat penalaran untuk menghemat biaya.

• Pengaturan sampling bersifat tetap. Nilai seperti temperature, top_p, dan penalti terkunci, jadi hilangkan dari permintaan alih-alih menyetelnya.

• Keluaran bisa menjadi panjang dan mahal. Batasi max_completion_tokens, seperti pada contoh, dan validasi setiap loop agen.

• URL gambar publik tidak didukung melalui API, jadi rencanakan base64 atau file yang diunggah untuk vision di sana.

Tidak ada satupun dari ini yang menjadi penghalang, tetapi hal-hal tersebut membentuk cara Anda menggunakan model. Biaya keluaran adalah yang paling saya perhatikan.

Kesimpulan

Dalam pengujian saya, dua hal menonjol. Pemanggilan tool dan keluaran terstruktur tidak memerlukan percobaan ulang, dan caching lebih penting dari yang saya perkirakan, karena menggunakan kembali prefix panjang yang sama membuat permintaan besar menjadi murah untuk dikirim ulang. Jadi untuk analisis level repositori, pemanggilan konteks panjang berulang, atau rekayasa multimodal, K3 adalah default yang masuk akal; untuk chat cepat berbiaya rendah atau kontrol sampling yang presisi, model yang lebih kecil lebih mudah dipilih. Detail bobot terbuka dan lisensi, yang sebelumnya saya soroti, seharusnya lebih jelas setelah rilis 27 Juli.

Untuk latar belakang lebih lanjut tentang pola yang digunakan contoh-contoh ini, kursus kami Developing AI Systems with the OpenAI API membahas function calling dan menghubungkan model ke tool eksternal di Python.