DEV Community

Cover image for Cara Menggunakan API Kimi K2.6
Walse
Walse

Posted on • Originally published at apidog.com

Cara Menggunakan API Kimi K2.6

Pengumuman Kimi K2.6 dari Moonshot AI menempatkannya sebagai teknologi mutakhir sumber terbuka yang baru untuk pemrograman, eksekusi jangka panjang, dan kelompok agen (agent swarms). API yang mendukungnya kompatibel dengan OpenAI, di-host di https://api.moonshot.ai/v1, dan didokumentasikan di platform. Jika Anda memiliki SDK OpenAI yang terinstal, Anda dapat mengirim permintaan nyata dalam waktu sekitar lima menit.

Coba Apidog hari ini

Panduan ini membahas autentikasi, permintaan pertama, streaming, pemanggilan alat, input visi dan video, mode berpikir, cara mengoperasikan Agent Swarm dengan 300 sub-agen, serta bagaimana menguji setiap *endpoint* dengan Apidog sebelum menulis kode integrasi.

💡Jalur cepat: Uji API Kimi K2.6 secara visual di Apidog sebelum melakukan commit kode integrasi apa pun. Satu impor, satu token Bearer, dan Anda membuat permintaan stream nyata dengan riwayat lengkap dan validasi skema. Unduh Apidog secara gratis.

TL;DR: API Kimi K2.6 dalam 60 Detik

  • URL Dasar: https://api.moonshot.ai/v1
  • Endpoint: POST /chat/completions
  • ID Model: kimi-k2.6, kimi-k2.6-thinking
  • Otentikasi: Authorization: Bearer $KIMI_API_KEY
  • Format: Skema penyelesaian chat OpenAI (messages, tools, stream, dll.)
  • Konteks: 262.144 token input, hingga 98.304 token output untuk penalaran
  • Standar Bawaan: temperature 1.0, top-p 1.0 (lihat panduan resmi)

Contoh minimal dengan curl:

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "Write a Python function that reverses a string."}]
  }'
Enter fullscreen mode Exit fullscreen mode

Sisa panduan ini membahas detail implementasi, penggunaan Agent Swarm, serta batas eksekusi 4.000 langkah.

Kimi K2.6

Apa yang Benar-Benar Bisa Anda Lakukan dengan API Ini

Dari pengumuman Kimi K2.6, API ini membuka peluang aplikasi berikut:

  • Agen pemrograman yang berjalan 12+ jam pada satu tugas (demo: 4.000+ panggilan alat, throughput naik dari 15 jadi 193 token/detik).
  • Manajemen infrastruktur otonom untuk sesi multi-hari dengan respons insiden otomatis.
  • Keandalan jangka panjang di Rust, Go, Python, Zig.
  • Kelompok agen hingga 300 sub-agen, 4.000+ langkah terkoordinasi.
  • Pengembangan full-stack: aplikasi, otentikasi, database, transaksi dari satu prompt.
  • Vision + Python (MathVision + Python, akurasi 93.2%).

Jika Anda membangun alat seperti penggunaan komputer Claude Code, bangun Claude Code sendiri, atau Cursor Composer 2, API K2.6 adalah pengganti langsung pada lapisan model.

Langkah 1: Dapatkan Kunci API

  1. Daftar di platform.moonshot.ai atau platform.kimi.ai. Bisa pakai email/Google OAuth.
  2. Verifikasi akun. User internasional mungkin perlu verifikasi SMS.
  3. Tambahkan pembayaran (biasanya ada kredit gratis untuk akun baru).
  4. Buka Kunci API di dashboard dan klik Buat Kunci.
  5. Salin kunci (hanya muncul sekali).
  6. Ekspor: 
export KIMI_API_KEY="sk-..."
Enter fullscreen mode Exit fullscreen mode

Tambahkan ke .zshrc/.bashrc atau pengelola rahasia produksi. Jangan commit ke repo.

Ingin dev gratis? Cara Menggunakan Kimi K2.6 secara Gratis membahas Workers AI, self-hosted weights, dan program kredit gratis.

Langkah 2: Pilih SDK

API kompatibel dengan OpenAI; cukup ganti base_url di SDK OpenAI.

Pilihan Instalasi Terbaik untuk
curl bawaan Tes cepat, CI
OpenAI Python pip install openai Layanan Python
OpenAI Node npm install openai Aplikasi JS/TS

Python 

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Node.js 

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

console.log(response.choices[0].message.content);
Enter fullscreen mode Exit fullscreen mode

curl 

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'
Enter fullscreen mode Exit fullscreen mode

Ketiga cara di atas mengembalikan respons dengan format yang sama.

Langkah 3: Struktur Permintaan

Gunakan struktur body mirip OpenAI Chat:

{
  "model": "kimi-k2.6",
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    { "role": "user", "content": "Your prompt here." }
  ],
  "temperature": 1.0,
  "top_p": 1.0,
  "max_tokens": 8192,
  "stream": false,
  "tools": [],
  "tool_choice": "auto",
  "thinking": { "type": "disabled" }
}
Enter fullscreen mode Exit fullscreen mode

Catatan penting Moonshot:

  • Standar default tinggi: Blog resmi merekomendasikan temperature 1.0/top-p 1.0. Hindari default OpenAI (0.2) untuk pemrograman.
  • thinking: aktif/nonaktif jejak penalaran pada kimi-k2.6-thinking. { "type": "disabled" } mempercepat respons.

Langkah 4: Streaming

Streaming cocok untuk UI/generasi panjang. Output penalaran bisa 98.304 token—jangan tunggu sekaligus!

Python:

stream = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Write a 500-word essay on MoE models."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
Enter fullscreen mode Exit fullscreen mode

Node.js:

const stream = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "Write a 500-word essay on MoE models." }],
  stream: true,
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}
Enter fullscreen mode Exit fullscreen mode

Streaming juga berjalan pada pemanggilan alat; argumen tiba sebagai delta JSON.

Langkah 5: Pemanggilan Alat

Moonshot melaporkan Toolathlon 50% dan success rate 96.60%. Skema sama dengan OpenAI function calling.

Definisikan alat:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]
Enter fullscreen mode Exit fullscreen mode

Panggilan pertama (model memutuskan):

import json

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

resp = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

msg = resp.choices[0].message
messages.append(msg)

if msg.tool_calls:
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = fetch_weather(args["location"], args.get("unit", "celsius"))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
Enter fullscreen mode Exit fullscreen mode

Panggilan kedua (jawaban akhir):

final = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
)
print(final.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

K2.6 kuat untuk rantai alat multi-langkah, cocok untuk agen pemrograman berjalan lama seperti Kimi Code.

Langkah 6: Input Visi

K2.6: 79.4% di MMMU-Pro, 96.9% di V* (dengan Python). Gambar masuk via image_url pada pesan user:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in one sentence."},
                {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

File lokal ke base64:

import base64
with open("photo.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

image_url = f"data:image/jpeg;base64,{b64}"
Enter fullscreen mode Exit fullscreen mode

Untuk OCR/diagram, sertakan instruksi teks jelas + gambar. Tugas matematika: aktifkan alat Python.

Langkah 7: Input Video

Kirim URL video atau array frame:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Summarize what happens in this video."},
                {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}}
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Klip <30 detik bisa satu panggilan. Untuk video lebih panjang, gunakan streaming.

Langkah 8: Mode Berpikir

kimi-k2.6-thinking menampilkan jejak penalaran (mirip OpenAI o1). Moonshot: 96.4% AIME 2026, 90.5% GPQA-Diamond di mode ini.

Mode berpikir aktif:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Prove sqrt(2) is irrational."}],
)
Enter fullscreen mode Exit fullscreen mode

Nonaktif:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Quick: what's 17 * 23?"}],
    extra_body={"thinking": {"type": "disabled"}},
)
Enter fullscreen mode Exit fullscreen mode

Jejak penalaran dikembalikan di field reasoning.

Langkah 9: Agent Swarm

Agent Swarm = hingga 300 sub-agen, 4.000+ langkah. Aktifkan via parameter:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": "Build a 5-page marketing site for a coffee brand with responsive design and a newsletter signup."
    }],
    extra_body={
        "agent": {
            "type": "swarm",
            "max_agents": 30,
            "max_steps": 4000
        }
    },
)
Enter fullscreen mode Exit fullscreen mode

Tips praktis:

  1. Gunakan streaming untuk progress dan interupsi.
  2. Batasi max_agents (10–30 cukup).
  3. Pantau penggunaan token dari field usage.

Demo resmi: modifikasi 4.000+ baris kode selama 13 jam.

Langkah 10: Uji Semuanya dengan Apidog

Setiap fitur butuh format body/header berbeda. Apidog mempercepat debugging visual.

Apidog Streaming

Setup Kimi K2.6 di Apidog

  1. Unduh Apidog & buat proyek.
  2. Buat environment kimi-prod:
    • BASE_URL = https://api.moonshot.ai/v1
    • KIMI_API_KEY = sk-...
  3. Permintaan baru: POST {{BASE_URL}}/chat/completions
  4. Header:
    • Authorization: Bearer {{KIMI_API_KEY}}
    • Content-Type: application/json
  5. Body contoh streaming: 
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
Enter fullscreen mode Exit fullscreen mode
  1. Klik Kirim. Token mengalir real time di panel respons.

Keunggulan Apidog

  • Validasi skema sesuai OpenAI schema.
  • Riwayat permintaan untuk replay.
  • Switch environment dev/staging/prod sekali klik.
  • Berbagi tim via ekspor proyek (lihat panduan tim 50+ engineer).
  • Mock server untuk development saat Moonshot offline.
  • Dukungan stream SSE untuk format streaming Kimi.

Untuk editor, gunakan ekstensi VS Code Apidog. Cara migrasi dari Postman juga tersedia.

Penanganan Kesalahan

Moonshot memakai kode HTTP standar:

  • 400: bad request (body/param salah)
  • 401: auth gagal (token salah/kadaluarsa)
  • 429: rate limit/kuota habis
  • 500: server error, ulangi dengan exponential backoff
  • 529: overload, retry beberapa detik lagi

Pembungkus retry:

import time
from openai import OpenAI, RateLimitError, APIError

def call_kimi(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="kimi-k2.6",
                messages=messages,
            )
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
    raise RuntimeError("Kimi K2.6 failed after retries")
Enter fullscreen mode Exit fullscreen mode

Untuk disconnect di tengah stream, lacak token dan lanjutkan dengan instruksi "lanjutkan dari sini". Output reasoning 98.304 token = stream panjang = normal.

Pengendalian Biaya

Lihat harga resmi.

Tips produksi:

  • Batasi max_tokens: minimal sesuai kebutuhan (2048 cukup untuk chat).
  • Cache prompt sistem: Moonshot caching aktif di sistem prompt yang statis.
  • Catat field usage pada respons ke sistem metrik (Prometheus, dsb) + alert.

Pola Produksi: Perbaikan Masalah GitHub

Contoh: agen yang membaca issue GitHub, mencari kode, mengusulkan fix, dan menjalankan test menggunakan loop function calling Kimi K2.6:

from openai import OpenAI
import os, json

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

tools = [
    {"type": "function", "function": {
        "name": "read_file",
        "description": "Read a file in the repo.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
        }
    }},
    {"type": "function", "function": {
        "name": "search_code",
        "description": "Ripgrep the codebase for a pattern.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }},
    {"type": "function", "function": {
        "name": "run_tests",
        "description": "Run the project test suite.",
        "parameters": {"type": "object", "properties": {}}
    }},
]

def tool_dispatch(name, args):
    if name == "read_file":
        with open(args["path"]) as f:
            return f.read()
    if name == "search_code":
        return run_ripgrep(args["query"])
    if name == "run_tests":
        return run_pytest()
    raise ValueError(f"Unknown tool: {name}")

messages = [
    {"role": "system", "content": "You are a senior engineer. Fix the described bug."},
    {"role": "user", "content": "Issue: login form submits twice on slow networks."}
]

while True:
    resp = client.chat.completions.create(
        model="kimi-k2.6",
        messages=messages,
        tools=tools,
    )
    msg = resp.choices[0].message
    messages.append(msg)

    if not msg.tool_calls:
        print(msg.content)
        break

    for call in msg.tool_calls:
        result = tool_dispatch(call.function.name, json.loads(call.function.arguments))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })
Enter fullscreen mode Exit fullscreen mode

Bisa diskalakan ke Agent Swarm (tambahkan config ke extra_body). Juga cocok untuk multi-agent Hermes.

FAQ

Perlu SDK Moonshot khusus?

Tidak. SDK OpenAI Python/Node cukup, ganti base_url.

Ada rate limit?

Ya. Sesuai tier dan history penggunaan (cek dashboard).

Kompatibel dengan LangChain, LlamaIndex, Vercel AI SDK?

Ya, semua framework dengan OpenAI-compatible base_url.

Mendukung mode JSON?

Ya. Gunakan response_format: {"type": "json_object"} atau schema ketat.

Seberapa besar jendela konteks?

262.144 token input, 98.304 token output (lihat blog resmi).

Fine-tuning via API?

Belum. Untuk sekarang, fine-tuning via weights open source.

Bedanya kimi-k2.6 vs kimi-k2.6-thinking?

kimi-k2.6: cepat, jawaban langsung.

kimi-k2.6-thinking: expose reasoning steps, tuning matematika/logika.

Tingkatan gratis?

Lihat panduan akses gratis Kimi K2.6 untuk Workers AI, chat kimi.com, dsb.

Ringkasan

Kimi K2.6 bisa diintegrasikan ke toolchain OpenAI-compatible hanya dengan dua perubahan: base_url & API key. Anda dapatkan jendela konteks 262K, Agent Swarm (300 agen), function calling sukses >96%, dan fallback open source weights.

Untuk integrasi baru, gunakan Apidog untuk membangun & verifikasi setiap endpoint lebih dulu: temukan bug schema, streaming, dan otentikasi sebelum ke codebase utama. Setelah itu, porting permintaan ke Python/Node dengan percaya diri.

Referensi dan Bacaan Lanjut

Top comments (0)