Cara Menggunakan Kimi VL Thinking API Secara Gratis

Model bahasa visual (VLMs) telah merevolusi kemampuan AI untuk memahami dan menalar tentang konten visual. Di antara inovasi ini, model Kimi VL Thinking dari Moonshot AI menonjol sebagai yang sangat mengesankan—menggabungkan kemampuan penalaran tingkat lanjut dengan efisiensi yang luar biasa. Tutorial ini akan memandu Anda memahami kemampuan Kimi VL Thinking dan cara menggunakannya secara gratis melalui platform OpenRouter.

Tolok Ukur Kimi VL Thinking

Kimi VL Thinking (secara resmi disebut Kimi-VL-A3B-Thinking) adalah model bahasa visual canggih yang dikembangkan oleh Moonshot AI. Yang membuat model ini istimewa adalah arsitektur Mixture-of-Experts (MoE) yang hanya mengaktifkan 2,8 miliar parameter per langkah inferensi, sementara secara total berisi sekitar 16 miliar parameter. Hal ini memungkinkannya untuk memberikan penalaran yang canggih dengan komputasi yang relatif efisien.

Kimi VL Thinking dirancang khusus untuk tugas-tugas penalaran tingkat lanjut, terutama yang membutuhkan pemikiran langkah demi langkah dan analisis matematis dari input visual. Model ini dibuat dengan menyempurnakan model dasar Kimi VL dengan pembelajaran terawasi rantai-pemikiran (CoT) dan teknik pembelajaran penguatan.

Sorotan Utama Model Kimi VL Thinking

Jendela Konteks Panjang: Mendukung hingga 128 ribu token, memungkinkan percakapan multi-giliran yang ekstensif dan pemrosesan dokumen panjang.
Visi Resolusi Asli: Menggunakan encoder MoonViT untuk memproses input visual resolusi tinggi dengan pengenalan detail yang sangat baik.
Penalaran Tingkat Lanjut: Sangat kuat dalam penalaran visual matematis dan pemecahan masalah langkah demi langkah.
Komputasi Efisien: Terlepas dari kemampuannya yang kuat, model ini hanya mengaktifkan 2,8 miliar parameter, membuatnya lebih mudah diakses daripada alternatif yang lebih besar.
Sumber Terbuka: Tersedia di bawah lisensi MIT, memungkinkan aplikasi akademik dan komersial yang luas.

Kinerja Tolok Ukur Kimi VL Thinking

Kimi VL Thinking menunjukkan kinerja yang mengesankan di beberapa tolok ukur yang menantang, sering kali menyaingi atau melampaui model yang jauh lebih besar:

MathVision: Mencapai skor 36,8 (Pass@1), sebanding dengan model seperti Gemma-3-27B (35,5) dan mendekati Qwen2.5-VL-72B (38,1).
MathVista: Mencetak 71,3 pada tolok ukur mini, mengungguli model seperti GPT-4o-mini (56,7) dan Gemma-3-12B (56,4).
MMMU (Multimodal Massive Multitask Understanding): Mencapai 61,7 pada set validasi, menunjukkan kemampuan yang kuat dalam tugas multimodal yang kompleks.

Untuk menempatkan hasil ini dalam perspektif, kinerja Kimi VL Thinking sangat luar biasa mengingat ia hanya mengaktifkan 2,8 miliar parameter, sementara bersaing dengan model yang menggunakan 7 miliar, 12 miliar, atau bahkan 70 miliar+ parameter. Ini memposisikannya sebagai salah satu VLM berkemampuan penalaran paling efisien yang tersedia.

Cara Menggunakan Kimi VL Thinking Gratis Melalui OpenRouter

OpenRouter menyediakan cara mudah untuk mengakses Kimi VL Thinking tanpa perlu menyebarkan model sendiri. Tingkat gratis mereka memungkinkan Anda bereksperimen dengan model tanpa biaya apa pun. Berikut cara memulainya:

Langkah 1: Buat Akun OpenRouter

Kunjungi situs web OpenRouter dan daftar akun jika Anda belum memilikinya.
Setelah pendaftaran, navigasikan ke pengaturan akun Anda untuk menghasilkan kunci API.
Simpan kunci API ini dengan aman, karena Anda akan membutuhkannya untuk semua panggilan API.

Langkah 2: Memahami Struktur API OpenRouter

API OpenRouter dirancang agar kompatibel dengan format API OpenAI, sehingga mudah diintegrasikan jika Anda sudah familiar dengan layanan OpenAI. Perbedaan utamanya adalah:

URL dasar: https://openrouter.ai/api/v1
Nama model: moonshotai/kimi-vl-a3b-thinking:free
Header opsional tambahan untuk analitik

Langkah 3: Melakukan Panggilan API Pertama Anda

Untuk pengguna Python, siapkan lingkungan Anda dengan dependensi ini:

pip install openai requests pillow

Mari kita mulai dengan contoh dasar menggunakan OpenAI SDK, yang merupakan pendekatan paling mudah:

from openai import OpenAI
from base64 import b64encode
from PIL import Image
import io

# Inisialisasi klien dengan URL dasar OpenRouter
client = OpenAI(
    base_url="<https://openrouter.ai/api/v1>",
    api_key="your_openrouter_api_key_here",
)

# Fungsi untuk menyandikan gambar
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return b64encode(image_file.read()).decode('utf-8')

# Muat dan sandikan gambar Anda
image_path = "path_to_your_image.jpg"
base64_image = encode_image(image_path)

# Buat permintaan API
completion = client.chat.completions.create(
    extra_headers={
        "HTTP-Referer": "your_site_url",  # Opsional untuk analitik
        "X-Title": "your_app_name",       # Opsional untuk analitik
    },
    model="moonshotai/kimi-vl-a3b-thinking:free",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                },
                {
                    "type": "text",
                    "text": "Please examine this mathematical problem and solve it step by step."
                }
            ]
        }
    ],
    max_tokens=1024
)

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

Jika Anda lebih suka menggunakan panggilan API langsung tanpa SDK:

import requests
import json
from base64 import b64encode

# Fungsi untuk menyandikan gambar
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return b64encode(image_file.read()).decode('utf-8')

# Muat dan sandikan gambar Anda
image_path = "path_to_your_image.jpg"
base64_image = encode_image(image_path)

# Buat permintaan API
response = requests.post(
    url="<https://openrouter.ai/api/v1/chat/completions>",
    headers={
        "Authorization": "Bearer your_openrouter_api_key_here",
        "Content-Type": "application/json",
        "HTTP-Referer": "your_site_url",  # Opsional untuk analitik
        "X-Title": "your_app_name",       # Opsional untuk analitik
    },
    data=json.dumps({
        "model": "moonshotai/kimi-vl-a3b-thinking:free",
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}"
                        }
                    },
                    {
                        "type": "text",
                        "text": "Please examine this mathematical problem and solve it step by step."
                    }
                ]
            }
        ],
        "max_tokens": 1024
    })
)

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

Untuk respons yang panjang atau pengalaman pengguna yang lebih baik, Anda mungkin ingin melakukan streaming output model:

from openai import OpenAI
from base64 import b64encode

client = OpenAI(
    base_url="<https://openrouter.ai/api/v1>",
    api_key="your_openrouter_api_key_here",
)

# Fungsi untuk menyandikan gambar
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return b64encode(image_file.read()).decode('utf-8')

# Muat dan sandikan gambar Anda
image_path = "path_to_your_image.jpg"
base64_image = encode_image(image_path)

# Buat permintaan streaming
stream = client.chat.completions.create(
    model="moonshotai/kimi-vl-a3b-thinking:free",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                },
                {
                    "type": "text",
                    "text": "Please examine this mathematical problem and solve it step by step."
                }
            ]
        }
    ],
    stream=True,
    max_tokens=1024
)

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

Menguji API Kimi VL Thinking dengan Apidog

Apidog adalah alat pengujian API komprehensif yang menyederhanakan proses berinteraksi dengan API seperti Kimi VL Thinking. Fitur-fiturnya, seperti manajemen lingkungan dan simulasi skenario, menjadikannya ideal untuk pengembang. Mari kita lihat cara menggunakan Apidog untuk menguji API Kimi VL Thinking.

tombol

Siapkan Apidog

Pertama, unduh dan instal Apidog dari apidog.com. Setelah diinstal, buat proyek baru dan tambahkan titik akhir API Kimi VL Thinking: https://openrouter.ai/api/v1/chat/completions.

Konfigurasikan Lingkungan Anda

Selanjutnya, siapkan lingkungan yang berbeda (misalnya, pengembangan dan produksi) di Apidog. Tentukan variabel seperti kunci API dan URL dasar Anda untuk dengan mudah beralih antar pengaturan. Di Apidog, buka tab "Environments" dan tambahkan:

api_key: Kunci API OpenRouter Anda
base_url: https://openrouter.ai/api/v1

Buat Permintaan Pengujian

Sekarang, buat permintaan POST baru di Apidog.

Atur URL ke {{base_url}}/chat/completions, tambahkan header Anda, dan masukkan badan JSON:

{
    "model": "quasar-alpha",
    "messages": [
        {"role": "user", "content": "Explain the difference between let and const in JavaScript."}
    ],
    "max_tokens": 300
}

Di bagian header, tambahkan:

Authorization: Bearer {{api_key}}
Content-Type: application/json

Jalankan dan Analisis Pengujian

Terakhir, kirim permintaan dan analisis respons di antarmuka visual Apidog. Apidog menyediakan laporan terperinci, termasuk waktu respons, kode status, dan penggunaan token. Anda juga dapat menyimpan permintaan ini sebagai skenario yang dapat digunakan kembali untuk pengujian di masa mendatang.

Kemampuan Apidog untuk mensimulasikan skenario dunia nyata dan menghasilkan laporan yang dapat diekspor menjadikannya alat yang ampuh untuk men-debug dan mengoptimalkan interaksi Anda dengan API Kimi VL Thinking. Mari kita akhiri dengan beberapa praktik terbaik.

tombol

Mengoptimalkan Prompt untuk Kimi VL Thinking

Kimi VL Thinking unggul dalam penalaran langkah demi langkah, jadi susun prompt Anda untuk memanfaatkan kemampuan ini:

Bersikaplah Eksplisit Tentang Penalaran: Minta model untuk "berpikir langkah demi langkah" atau "menalar masalah ini dengan hati-hati."
Satu Tugas dalam Satu Waktu: Untuk masalah yang kompleks, pecah menjadi langkah-langkah yang dapat dikelola daripada meminta semuanya sekaligus.
Berikan Konteks: Jika relevan, berikan informasi latar belakang yang dapat membantu model memahami masalah dengan lebih baik.
Gunakan Instruksi yang Jelas: Tentukan dengan tepat apa yang Anda ingin model analisis dalam gambar.

Kesimpulan

Kimi VL Thinking mewakili pencapaian yang mengesankan dalam model bahasa visual yang efisien namun kuat. Kemampuannya untuk melakukan penalaran tingkat lanjut sambil hanya mengaktifkan 2,8 miliar parameter membuatnya dapat diakses oleh lebih banyak pengguna daripada model besar tradisional.

Dengan memanfaatkan tingkat gratis OpenRouter, Anda dapat bereksperimen dengan teknologi mutakhir ini tanpa hambatan biaya. Apakah Anda sedang mengerjakan aplikasi pendidikan, analisis data, atau dokumentasi teknis, Kimi VL Thinking menawarkan alat yang ampuh untuk memahami dan menalar tentang konten visual.

Saat Anda menjadi lebih nyaman dengan model ini, Anda dapat menjelajahi kasus penggunaan yang lebih kompleks dan berpotensi mengintegrasikannya ke dalam aplikasi produksi. Ingatlah bahwa tingkat gratis sangat cocok untuk eksperimen, tetapi untuk kasus penggunaan produksi dengan volume tinggi, Anda mungkin mempertimbangkan untuk meningkatkan ke tingkat berbayar untuk keandalan dan jaminan kinerja yang lebih baik.

Mulai jelajahi Kimi VL Thinking hari ini dan temukan bagaimana kemampuan penalaran visual tingkat lanjut dapat meningkatkan proyek Anda!