Integrasi Kimi K2.5 Cursor: Coding Bertenaga AI di IDE Anda

// Contoh nilai untuk penyedia yang kompatibel dengan OpenAI
{
  "provider": "openai-compatible",
  "apiKey": "YOUR_MOONSHOT_API_KEY",
  "baseUrl": "https://api.moonshot.cn/v1",
  "model": "kimi-k2.5"
}

{
  "provider": "openai-compatible",
  "apiKey": "YOUR_OPENROUTER_API_KEY",
  "baseUrl": "https://openrouter.ai/api/v1",
  "model": "moonshotai/kimi-k2.5"
}

# Ketik:
def calculate_fibonacci(n):
    # Cursor + Kimi K2.5 menyarankan:
    """
    Menghitung bilangan Fibonacci ke-n.

    Args:
        n: Posisi dalam deret Fibonacci (dimulai dari 0)

    Returns:
        Bilangan Fibonacci ke-n

    Raises:
        ValueError: Jika n bernilai negatif
    """
    if n < 0:
        raise ValueError("n must be non-negative")
    if n <= 1:
        return n

    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

Pengguna: "Tambahkan penanganan error dan logging ke fungsi ini"
Kimi K2.5: [Menghasilkan kode yang lebih baik dengan blok try-except dan logging]

Pengguna: "Jelaskan cara kerja komponen React ini dan sarankan optimasinya"
Kimi K2.5: [Memberikan penjelasan rinci dan 3 saran optimasi]

Prompt: "Temukan semua penggunaan API usang di @src dan sarankan
pengganti modern beserta contoh implementasinya"

# Pilih fungsi Anda
def divide_numbers(a, b):
    return a / b

# Prompt: "Buat unit test menyeluruh termasuk edge case"
# Kimi K2.5 menghasilkan:
import pytest

def test_divide_numbers_normal():
    assert divide_numbers(10, 2) == 5

def test_divide_numbers_float():
    assert divide_numbers(7, 2) == 3.5

def test_divide_numbers_negative():
    assert divide_numbers(-10, 2) == -5

def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError):
        divide_numbers(10, 0)

# Pilih kode tanpa dokumentasi
class DataProcessor:
    def __init__(self, config):
        self.config = config
        self.cache = {}

    def process(self, data):
        if data.id in self.cache:
            return self.cache[data.id]
        result = self._transform(data)
        self.cache[data.id] = result
        return result

# Prompt: "Buat docstring yang menyeluruh"
# Kimi K2.5 menghasilkan kode dengan dokumentasi lengkap

{
  "cursor.customCommands": [
    {
      "name": "Review Security",
      "prompt": "Review this code for security vulnerabilities including SQL injection, XSS, and insecure data handling. Provide specific fixes."
    },
    {
      "name": "Optimize Performance",
      "prompt": "Analyze this code for performance bottlenecks. Suggest optimizations with Big O analysis."
    },
    {
      "name": "Add Type Hints",
      "prompt": "Add comprehensive Python type hints to this code, including generics and overloads where appropriate."
    }
  ]
}

Prompt: "Buat pesan commit untuk perubahan di @git diff"

Kimi K2.5: "feat(auth): implement JWT token refresh mechanism

- Add automatic token refresh 5 minutes before expiry
- Store refresh tokens in httpOnly cookies
- Add retry logic for failed authenticated requests
- Update tests for new auth flow"

# Tempelkan traceback error
Prompt: "Bantu saya men-debug error ini: [tempel stack trace]"

Kimi K2.5 menganalisis:
1. Identifikasi akar penyebab
2. Penyorotan berkas dan nomor baris
3. Saran perbaikan beserta contoh kode
4. Strategi pencegahan

# Inferensi type hint
# Prompt: "Tambahkan type hint"
def process_data(data, options):
    # Kimi K2.5 menyarankan:
    from typing import Dict, Any, Optional

    def process_data(
        data: Dict[str, Any],
        options: Optional[Dict[str, bool]] = None
    ) -> Dict[str, Any]:

// Pembuatan komponen React
// Prompt: "Buat React hook untuk data fetching dengan caching"

// Kimi K2.5 menghasilkan:
import { useCallback, useEffect, useState } from 'react';

interface UseFetchOptions {
  cacheTime?: number;
  retryCount?: number;
}

export function useFetch<T>(url: string, options: UseFetchOptions = {}) {
  // Implementasi dengan tipe TypeScript yang tepat
}

// Bantuan anotasi lifetime
// Prompt: "Perbaiki masalah lifetime pada kode ini"

// Kimi K2.5 menyediakan versi yang sudah diperbaiki dengan:
// - Parameter lifetime yang tepat
// - Klarifikasi ownership
// - Optimasi borrowing

# Baik: Spesifik dan kontekstual
"@database.py Review the connection pooling implementation
for thread safety issues"

# Kurang efektif: Samar
"Check this code for bugs"

# Verifikasi API key Anda
curl https://api.moonshot.ai/v1/models \
  -H "Authorization: Bearer YOUR_KEY"

// Verifikasi konfigurasi
{
  "provider": "openai-compatible",
  "apiKey": "sk-...",
  "baseUrl": "https://api.moonshot.cn/v1",
  "model": "kimi-k2.5"
}

"Create a FastAPI endpoint that accepts JSON,
validates with Pydantic, and stores in PostgreSQL"

"Convert this Python 2 script to Python 3,
following modern best practices and adding type hints"

"@src Explain the architecture of this project
and how data flows from frontend to database"