Kimi K2.5 API: Panduan Developer Lengkap dengan Contoh Kode 2026

Feb 3, 2026

New to Kimi K2.5?Try Kimi K2.5.

Kimi K2.5 API memberi developer akses programatis ke model unggulan Moonshot AI. Panduan menyeluruh ini membahas segala hal mulai dari autentikasi hingga pola integrasi tingkat lanjut, membantu Anda membangun aplikasi AI yang andal dengan Kimi K2.5.

Apa itu Kimi K2.5 API?

Kimi K2.5 API adalah antarmuka RESTful yang memungkinkan developer mengintegrasikan kemampuan Kimi K2.5 ke dalam aplikasi mereka. Dibangun di atas format API yang kompatibel dengan OpenAI, API ini menyediakan integrasi mulus dengan tool dan framework yang sudah ada, sekaligus mendukung fitur khas Kimi K2.5 seperti context window 256K dan input multimodal.

Fitur Utama

FiturDeskripsi
Context Window 256KMemproses dokumen hingga ~200 halaman
Dukungan MultimodalInput teks, gambar, dan dokumen
Respons StreamingPembuatan token secara real-time
Function CallingPenggunaan tool dan alur kerja agentik
Kompatibel OpenAIPengganti langsung untuk OpenAI SDK
Context CachingBiaya lebih rendah untuk konteks berulang

Memulai dengan Kimi K2.5 API

1. Memperoleh Kredensial API

Daftar untuk mendapatkan API key di Platform Moonshot AI:

  1. Buat akun di portal developer Moonshot AI
  2. Buka bagian API Keys
  3. Buat API key baru
  4. Simpan dengan aman (disarankan menggunakan environment variable)

2. Base URL API

https://api.moonshot.cn/v1

3. Autentikasi

Semua permintaan API memerlukan autentikasi melalui Bearer token:

Authorization: Bearer YOUR_API_KEY

Contoh Kode Kimi K2.5 API

Integrasi Python

Chat Completion Dasar

import openai

# Konfigurasi client
client = openai.OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.cn/v1"
)

# Completion sederhana
response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Jelaskan machine learning dengan istilah sederhana."}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)

Respons Streaming

import openai

client = openai.OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.cn/v1"
)

stream = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {"role": "user", "content": "Tulis fungsi Python untuk menghitung bilangan fibonacci."}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Permintaan Multimodal dengan Gambar

import openai
import base64

client = openai.OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.cn/v1"
)

# Baca dan encode gambar
with open("chart.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analisis grafik ini dan rangkum tren utamanya."},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

Integrasi JavaScript/Node.js

Permintaan Dasar dengan Fetch

const response = await fetch('https://api.moonshot.cn/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_API_KEY'
  },
  body: JSON.stringify({
    model: 'kimi-k2.5',
    messages: [
      { role: 'system', content: 'You are a coding assistant.' },
      { role: 'user', content: 'Buat komponen React untuk daftar todo.' }
    ],
    temperature: 0.7,
    max_tokens: 2000
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Menggunakan OpenAI SDK

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'your-kimi-api-key',
  baseURL: 'https://api.moonshot.cn/v1'
});

async function generateCode() {
  const stream = await client.chat.completions.create({
    model: 'kimi-k2.5',
    messages: [
      { role: 'user', content: 'Buat API Python dengan FastAPI' }
    ],
    stream: true
  });

  for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0]?.delta?.content || '');
  }
}

generateCode();

Contoh cURL

# Chat completion dasar
curl https://api.moonshot.cn/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "kimi-k2.5",
    "messages": [
      {"role": "user", "content": "Halo, Kimi!"}
    ]
  }'

# Dengan system prompt dan parameter
curl https://api.moonshot.cn/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "kimi-k2.5",
    "messages": [
      {"role": "system", "content": "You are a Python expert."},
      {"role": "user", "content": "Jelaskan decorator."}
    ],
    "temperature": 0.3,
    "max_tokens": 1500
  }'

Fitur Lanjutan Kimi K2.5 API

Function Calling / Penggunaan Tool

import openai

client = openai.OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.cn/v1"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City name"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {"role": "user", "content": "What's the weather in Beijing?"}
    ],
    tools=tools
)

# Periksa apakah model ingin memanggil sebuah fungsi
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    print(f"Function to call: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")

Pemrosesan Dokumen Konteks Panjang

import openai

client = openai.OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.cn/v1"
)

# Baca dokumen panjang
document = open("annual_report.txt", "r", encoding="utf-8").read()

response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {
            "role": "user",
            "content": f"Summarize the key financial metrics from this report:\n\n{document}"
        }
    ],
    max_tokens=2000
)

print(response.choices[0].message.content)

Harga Kimi K2.5 API

TipeHargaSatuan
Context Cache Hit$0.10/ 1M token
Context Cache Miss$0.60/ 1M token
Output Token$3.00/ 1M token

Tips Optimasi Biaya

  1. Gunakan Context Caching: Untuk konteks berulang, caching menurunkan biaya secara signifikan
  2. Streaming Respons: Untuk aplikasi real-time, streaming meningkatkan pengalaman pengguna
  3. Optimalkan Prompt: Prompt yang jelas dan ringkas mengurangi penggunaan token
  4. Batch Permintaan: Proses beberapa item dalam satu permintaan jika memungkinkan

Penanganan Error

Kode Status HTTP Umum

KodeArtiSolusi
200BerhasilPermintaan selesai dengan sukses
400Bad RequestPeriksa format dan parameter permintaan
401UnauthorizedVerifikasi API key
429Rate LimitedKurangi frekuensi permintaan
500Server ErrorCoba lagi dengan exponential backoff

Contoh Penanganan Error di Python

import openai
from openai import RateLimitError, APIError

client = openai.OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.cn/v1"
)

try:
    response = client.chat.completions.create(
        model="kimi-k2.5",
        messages=[{"role": "user", "content": "Hello"}]
    )
except RateLimitError:
    print("Rate limit exceeded. Please wait before retrying.")
except APIError as e:
    print(f"API error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

Praktik Terbaik untuk Kimi K2.5 API

1. Pengelolaan API Key yang Aman

import os
from dotenv import load_dotenv

load_dotenv()

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

2. Terapkan Logika Retry

import time
from functools import wraps

def retry_with_backoff(max_retries=3):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if i == max_retries - 1:
                        raise
                    time.sleep(2 ** i)  # Exponential backoff
            return None
        return wrapper
    return decorator

@retry_with_backoff(max_retries=3)
def call_kimi_api(messages):
    return client.chat.completions.create(
        model="kimi-k2.5",
        messages=messages
    )

3. Batching Permintaan

# Alih-alih beberapa permintaan terpisah
requests = [
    "Summarize paragraph 1",
    "Summarize paragraph 2",
    "Summarize paragraph 3"
]

# Gabungkan menjadi satu permintaan
batch_prompt = "Summarize each of these paragraphs:\n\n" + "\n\n".join(
    f"{i+1}. {req}" for i, req in enumerate(requests)
)

response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[{"role": "user", "content": batch_prompt}]
)

Contoh Integrasi

Backend FastAPI

from fastapi import FastAPI
from pydantic import BaseModel
import openai

app = FastAPI()
client = openai.OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.cn/v1"
)

class ChatRequest(BaseModel):
    message: str
    temperature: float = 0.7

@app.post("/chat")
async def chat(request: ChatRequest):
    response = client.chat.completions.create(
        model="kimi-k2.5",
        messages=[{"role": "user", "content": request.message}],
        temperature=request.temperature
    )
    return {"response": response.choices[0].message.content}

FAQ

Bagaimana cara mendapatkan API key Kimi K2.5?

Kunjungi Platform Moonshot AI, buat akun, lalu buat API key dari dashboard developer.

Apakah Kimi K2.5 API kompatibel dengan OpenAI?

Ya, Kimi K2.5 API menggunakan format yang kompatibel dengan OpenAI. Anda bisa memakai OpenAI SDK dengan mengubah base_url menjadi https://api.moonshot.cn/v1.

Berapa rate limit untuk Kimi K2.5 API?

Rate limit didasarkan pada total akumulasi pengisian saldo (Tier0-Tier5), bukan paket Free/Pro/Enterprise. Sebagai contoh, Tier0 (pengisian ¥0) adalah 1 permintaan bersamaan, 3 RPM, 500,000 TPM, dan 1,500,000 TPD. Periksa halaman limit resmi untuk nilai terbaru.

Apakah Kimi K2.5 API mendukung streaming?

Ya, atur stream=True dalam permintaan Anda untuk menerima token saat dibuat, sehingga memungkinkan respons real-time.

Bisakah saya menggunakan Kimi K2.5 API untuk analisis gambar?

Ya, Kimi K2.5 API mendukung input multimodal termasuk gambar. Gunakan gambar berenkode base64 dalam pesan Anda.

Berapa biaya Kimi K2.5 API?

Harga mulai dari $0.10/1M token untuk cache hit, $0.60/1M untuk cache miss, dan $3.00/1M untuk output token.

Referensi

Kimi K2.5 API: Panduan Developer Lengkap dengan Contoh Kode 2026