Blog

Cara Menggunakan Kimi K2.5 API: Panduan Lengkap

Ashley Innocent

Ashley Innocent

27 January 2026

Cara Menggunakan Kimi K2.5 API: Panduan Lengkap

Pengembang semakin mencari API yang tangguh yang dapat menangani masukan multimodal yang kompleks dan menghasilkan keluaran yang cerdas. Kimi K2.5 API menonjol sebagai alat serbaguna dari Moonshot AI, yang memungkinkan aplikasi untuk memproses teks, gambar, dan video dengan kemampuan penalaran canggih. API ini memberdayakan Anda untuk membangun solusi berbasis AI yang canggih, mulai dari debugging visual dalam kode hingga mengorkestrasi kelompok agen untuk eksekusi tugas paralel.

💡
Ingin mengikuti? Unduh Apidog untuk menguji panggilan API Kimi K2.5 Anda secara visual. Apidog memungkinkan Anda mengonfigurasi permintaan, memeriksa respons, men-debug masalah autentikasi, dan menghasilkan kode siap produksi—semuanya tanpa menulis boilerplate. Ini adalah cara tercepat untuk bereksperimen dengan kemampuan K2.5 sebelum berkomitmen pada kode.
button

Apa itu Kimi K2.5?

Kimi K2.5 merepresentasikan model multimodal sumber terbuka paling canggih dari Moonshot AI, dibangun melalui pretraining berkelanjutan pada sekitar 15 triliun token visual dan teks campuran di atas arsitektur Kimi-K2-Base. Berbeda dengan pendahulunya, K2.5 secara mulus mengintegrasikan pemahaman visi dan bahasa dengan kemampuan keagenan canggih, menjadikannya sangat kuat bagi pengembang yang membangun aplikasi bertenaga AI.

Model ini memperkenalkan beberapa fitur inovatif yang membedakannya dari API AI lainnya. Multimodalitas aslinya berarti model ini dilatih di awal (pre-trained) pada token visi-bahasa dari dasar, daripada memiliki kemampuan visi yang ditambahkan sebagai pemikiran terakhir. Pendekatan ini menghasilkan kinerja superior dalam pengetahuan visual, penalaran lintas modal, dan penggunaan alat keagenan yang berakar pada masukan visual.

Mengapa Kimi K2.5 penting bagi pengembang:

Fitur dan Kemampuan Utama

Kecerdasan Multimodal Asli

K2.5 unggul dalam pengetahuan visual, penalaran lintas modal, dan penggunaan alat keagenan yang berakar pada masukan visual. Ini bukan hanya pengenalan gambar—ini adalah pemahaman mendalam tentang konteks visual yang dapat menginformasikan pengambilan keputusan yang kompleks.

Koding dengan Visi

Salah satu kemampuan menonjol K2.5 adalah menghasilkan kode dari spesifikasi visual. Arahkan ke maket desain UI, dan ia dapat menghasilkan kode front-end yang fungsional. Tunjukkan alur kerja video, dan ia dapat mengorkestrasi alat untuk pemrosesan data visual. Ini menjadikannya sangat berharga untuk:

Arsitektur Kelompok Agen

K2.5 beralih dari penskalaan agen tunggal ke skema eksekusi seperti kelompok yang terkoordinasi dan mandiri. Ketika dihadapkan dengan tugas-tugas kompleks, ia dapat:

  1. Menguraikan masalah menjadi sub-tugas paralel
  2. Secara dinamis menginisialisasi agen spesifik domain
  3. Mengkoordinasikan eksekusi di berbagai agen
  4. Mensintesis hasil menjadi keluaran yang koheren

Arsitektur ini memungkinkan K2.5 untuk menangani tugas-tugas yang akan membanjiri sistem agen tunggal, seperti refaktorisasi kode yang komprehensif, pembuatan dokumentasi multi-file, atau pipeline analisis data yang kompleks.

Kinerja Benchmark

Memulai dengan Kimi K2.5 API

Langkah 1: Buat Akun Moonshot AI Anda

Kunjungi platform.moonshot.ai dan daftar untuk membuat akun. Proses pendaftaran cukup mudah:

  1. Klik "Sign Up" atau "Register"
  2. Berikan email Anda dan buat kata sandi
  3. Verifikasi alamat email Anda
  4. Lengkapi informasi profil yang diperlukan

Langkah 2: Hasilkan Kunci API Anda

Setelah masuk:

  1. Navigasi ke bagian Kunci API di dasbor Anda
  2. Klik "Buat Kunci API Baru"
  3. Berikan nama deskriptif pada kunci Anda (misalnya, "kimi-k2-5-development")
  4. Salin dan simpan kunci API Anda dengan aman—Anda tidak akan melihatnya lagi

Tips keamanan: Jangan pernah memasukkan kunci API ke kontrol versi. Gunakan variabel lingkungan atau manajer rahasia.

Langkah 3: Siapkan Lingkungan Anda

Untuk Python:

pip install --upgrade 'openai>=1.0'

Untuk Node.js:

npm install openai@latest

Langkah 4: Konfigurasi Kunci API Anda

Atur kunci API Anda sebagai variabel lingkungan:

macOS/Linux:

export MOONSHOT_API_KEY="your-api-key-here"

Windows (PowerShell):

[System.Environment]::SetEnvironmentVariable("MOONSHOT_API_KEY", "your-api-key-here", "User")

Windows (Command Prompt):

setx MOONSHOT_API_KEY "your-api-key-here"

Contoh Kode Python

Penyelesaian Obrolan Dasar

Berikut adalah contoh sederhana untuk memulai dengan Kimi K2.5:

import os
from openai import OpenAI

# Initialize the client with Moonshot AI endpoint
client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Create a chat completion
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "system",
            "content": "You are Kimi, an AI assistant developed by Moonshot AI. You are helpful, harmless, and honest."
        },
        {
            "role": "user",
            "content": "Explain the concept of mixture-of-experts architecture in neural networks."
        }
    ],
    temperature=0.6,
    max_tokens=2048,
)

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

Respons Streaming

Untuk aplikasi real-time, gunakan streaming untuk menampilkan respons saat dibuat:

import os
from openai import OpenAI

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

# Stream the response
stream = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {"role": "user", "content": "Write a Python function to implement binary search."}
    ],
    stream=True,
    temperature=0.3,
)

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

Percakapan Multi-Giliran

Pertahankan konteks di berbagai pertukaran:

import os
from openai import OpenAI

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

conversation_history = [
    {"role": "system", "content": "You are a helpful coding assistant."}
]

def chat(user_message):
    conversation_history.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="kimi-k2.5-preview",
        messages=conversation_history,
        temperature=0.6,
    )

    assistant_message = response.choices[0].message.content
    conversation_history.append({"role": "assistant", "content": assistant_message})

    return assistant_message

# Example conversation
print(chat("How do I create a REST API in Python?"))
print(chat("Can you show me how to add authentication to that?"))
print(chat("What about rate limiting?"))

Implementasi Asynchronous

Untuk aplikasi berkinerja tinggi, gunakan async/await:

import os
import asyncio
from openai import AsyncOpenAI

async def main():
    client = AsyncOpenAI(
        api_key=os.environ.get("MOONSHOT_API_KEY"),
        base_url="https://api.moonshot.ai/v1",
    )

    # Run multiple requests concurrently
    tasks = [
        client.chat.completions.create(
            model="kimi-k2.5-preview",
            messages=[{"role": "user", "content": f"What is {topic}?"}],
        )
        for topic in ["REST API", "GraphQL", "gRPC"]
    ]

    responses = await asyncio.gather(*tasks)

    for response in responses:
        print(response.choices[0].message.content[:200])
        print("-" * 50)

asyncio.run(main())

Contoh JavaScript/Node.js

Penyelesaian Obrolan Dasar

import OpenAI from 'openai';

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

async function chat(userMessage) {
  const response = await client.chat.completions.create({
    model: 'kimi-k2.5-preview',
    messages: [
      {
        role: 'system',
        content: 'You are Kimi, a helpful AI assistant.',
      },
      {
        role: 'user',
        content: userMessage,
      },
    ],
    temperature: 0.6,
  });

  return response.choices[0].message.content;
}

// Usage
const answer = await chat('How do I implement a binary search tree in JavaScript?');
console.log(answer);

Streaming dengan Node.js

import OpenAI from 'openai';

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

async function streamChat(userMessage) {
  const stream = await client.chat.completions.create({
    model: 'kimi-k2.5-preview',
    messages: [{ role: 'user', content: userMessage }],
    stream: true,
  });

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

await streamChat('Explain microservices architecture');

Menggunakan Fetch API (Fungsi Peramban/Edge)

async function callKimiAPI(prompt) {
  const response = await fetch('https://api.moonshot.ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.MOONSHOT_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'kimi-k2.5-preview',
      messages: [{ role: 'user', content: prompt }],
      temperature: 0.6,
    }),
  });

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

// Usage
const result = await callKimiAPI('What are the best practices for API design?');
console.log(result);

Menguji Kimi K2.5 API dengan Apidog

Menguji API AI secara efektif membutuhkan pemahaman struktur permintaan/respons, penanganan streaming, pengelolaan autentikasi, dan debugging masalah. Apidog menyediakan solusi komprehensif untuk pengembangan API yang membuat bekerja dengan Kimi K2.5 menjadi mudah.

Menyiapkan Kimi K2.5 di Apidog

Langkah 1: Buat Proyek Baru

  1. Buka Apidog dan buat proyek baru bernama "Kimi K2.5 Integration"
  2. Ini mengatur semua endpoint terkait Kimi Anda di satu tempat

Langkah 2: Konfigurasi Variabel Lingkungan

  1. Navigasi ke Pengaturan Lingkungan
  2. Tambahkan variabel lingkungan baru:

Langkah 3: Buat Endpoint Penyelesaian Obrolan

  1. Tambahkan permintaan POST baru
  2. URL: https://api.moonshot.ai/v1/chat/completions
  3. Header:

Langkah 4: Konfigurasi Badan Permintaan

{
  "model": "kimi-k2.5-preview",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful AI assistant."
    },
    {
      "role": "user",
      "content": "Hello, how can you help me today?"
    }
  ],
  "temperature": 0.6,
  "max_tokens": 2048,
  "stream": false
}

Debugging dengan Apidog

Antarmuka visual Apidog membantu Anda:

Membuat Pengujian Otomatis

Dengan test runner Apidog, Anda dapat memverifikasi integrasi Kimi K2.5 Anda:

// Post-response test script in Apidog
pm.test("Response status is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response contains choices", function () {
    const response = pm.response.json();
    pm.expect(response.choices).to.be.an('array');
    pm.expect(response.choices.length).to.be.greaterThan(0);
});

pm.test("Response content is not empty", function () {
    const response = pm.response.json();
    pm.expect(response.choices[0].message.content).to.not.be.empty;
});

Panggilan Alat dan Kemampuan Agen

Salah satu fitur paling kuat dari Kimi K2.5 adalah kemampuannya untuk memanggil alat eksternal. Ini memungkinkan pembangunan agen AI canggih yang dapat berinteraksi dengan sistem eksternal.

Mendefinisikan Alat

import os
from openai import OpenAI

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

# Define available tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and country, e.g., 'London, UK'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Search a database for information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search query"
                    },
                    "limit": {
                        "type": "integer",
                        "description": "Maximum number of results"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# Make a request with tools
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {"role": "user", "content": "What's the weather like in Tokyo?"}
    ],
    tools=tools,
    tool_choice="auto",
)

# Handle tool calls
if response.choices[0].message.tool_calls:
    for tool_call in response.choices[0].message.tool_calls:
        print(f"Tool: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")

Mengeksekusi Panggilan Alat

import json

def execute_tool_call(tool_call):
    """Execute a tool call and return the result."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    if name == "get_weather":
        # Simulate weather API call
        return json.dumps({
            "location": args["location"],
            "temperature": 22,
            "unit": args.get("unit", "celsius"),
            "condition": "sunny"
        })
    elif name == "search_database":
        # Simulate database search
        return json.dumps({
            "results": [
                {"id": 1, "title": "Result 1"},
                {"id": 2, "title": "Result 2"}
            ]
        })

    return json.dumps({"error": "Unknown tool"})

# Complete the conversation with tool results
messages = [
    {"role": "user", "content": "What's the weather in Tokyo?"}
]

response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=messages,
    tools=tools,
)

if response.choices[0].message.tool_calls:
    # Add assistant message with tool calls
    messages.append(response.choices[0].message)

    # Execute each tool and add results
    for tool_call in response.choices[0].message.tool_calls:
        result = execute_tool_call(tool_call)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })

    # Get final response
    final_response = client.chat.completions.create(
        model="kimi-k2.5-preview",
        messages=messages,
        tools=tools,
    )

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

Fitur Visi dan Multimodal

Kemampuan multimodal asli K2.5 memungkinkan pemrosesan gambar bersama teks:

import os
import base64
from openai import OpenAI

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

def encode_image(image_path):
    """Encode image to base64."""
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Analyze an image
image_base64 = encode_image("screenshot.png")

response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Analyze this UI design and suggest improvements."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_base64}"
                    }
                }
            ]
        }
    ],
    max_tokens=2048,
)

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

Pembuatan Kode dari Masukan Visual

# Generate code from a wireframe
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "system",
            "content": "You are an expert frontend developer. Generate clean, production-ready code."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Convert this wireframe into a React component with Tailwind CSS styling."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{encode_image('wireframe.png')}"
                    }
                }
            ]
        }
    ],
    temperature=0.3,
)

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

Harga dan Batas Tarif

Poin-poin penting:

Praktik Terbaik dan Tips

Optimalkan Penggunaan Token

# Use system prompts efficiently
system_prompt = """You are a concise technical assistant.
Rules: 1) Be brief 2) Use code blocks 3) Skip pleasantries"""

# Enable caching for repeated contexts
# Moonshot automatically caches similar prompts

Pengaturan Suhu

Penanganan Kesalahan

from openai import OpenAI, APIError, RateLimitError

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

def safe_chat(message, retries=3):
    for attempt in range(retries):
        try:
            response = client.chat.completions.create(
                model="kimi-k2.5-preview",
                messages=[{"role": "user", "content": message}],
            )
            return response.choices[0].message.content
        except RateLimitError:
            if attempt < retries - 1:
                time.sleep(2 ** attempt)  # Exponential backoff
            else:
                raise
        except APIError as e:
            print(f"API Error: {e}")
            raise

result = safe_chat("Hello, Kimi!")

Memecahkan Masalah Umum

Kesalahan Autentikasi

Masalah: Kesalahan 401 Unauthorized

Solusi:

  1. Verifikasi kunci API Anda sudah benar
  2. Periksa bahwa kunci belum kedaluwarsa
  3. Pastikan format header Authorization sudah benar: Bearer KUNCI_ANDA

Pembatasan Tarif

Masalah: 429 Too Many Requests

Solusi:

  1. Implementasikan backoff eksponensial
  2. Tingkatkan tingkat Anda dengan menambahkan dana
  3. Pantau header X-RateLimit-Remaining

Panjang Konteks Terlampaui

Masalah: Permintaan melebihi batas token 256K

Solusi:

  1. Ringkas percakapan panjang
  2. Gunakan pendekatan jendela geser
  3. Pisah menjadi beberapa permintaan

Masalah Batas Waktu

Masalah: Permintaan mengalami batas waktu

Solusi:

  1. Gunakan streaming untuk respons panjang
  2. Tingkatkan pengaturan batas waktu klien
  3. Pecah prompt kompleks menjadi tugas yang lebih kecil

Siap membangun dengan Kimi K2.5? Unduh Apidog untuk merampingkan alur kerja pengembangan API Anda dengan pengujian visual, dokumentasi otomatis, dan fitur kolaborasi tim yang membuat integrasi API AI lebih cepat dan lebih andal.

button

Mengembangkan API dengan Apidog

Apidog adalah alat pengembangan API yang membantu Anda mengembangkan API dengan lebih mudah dan efisien.

Daftar gratisUnduh