Cara Menggunakan Qwen3.5 API Gratis dengan NVIDIA

TL;DR

Qwen3.5 adalah model visi-bahasa (vision-language model) terobosan dari Alibaba dengan 397 miliar parameter dan arsitektur Mixture of Experts (MoE). Anda bisa mengaksesnya secara gratis melalui endpoint yang dipercepat GPU dari NVIDIA dengan mendaftar di NVIDIA Developer Program. Panduan ini akan memandu Anda dalam mendapatkan kunci API, melakukan panggilan pertama Anda, dan mengintegrasikan kemampuan multimodal Qwen3.5 ke dalam aplikasi Anda.

Pendahuluan

Qwen3.5 dari Alibaba merepresentasikan lompatan signifikan dalam AI multimodal. Model 397 miliar parameter ini menggabungkan arsitektur Mixture of Experts (MoE) dengan Gated Delta Networks, memberikan kemampuan penalaran yang kuat sementara parameter aktif hanya 17 miliar. Hasilnya adalah model yang dapat memahami gambar, menavigasi antarmuka pengguna, dan menangani tugas multimodal yang kompleks, semuanya dapat diakses melalui API gratis.

Bagian terbaiknya? Anda bisa mulai menggunakan Qwen3.5 secara gratis sekarang juga melalui platform pengembang NVIDIA. Baik Anda sedang membangun agen AI, mengembangkan aplikasi penalaran visual, atau menjelajahi AI multimodal, panduan ini akan memandu Anda melalui setiap langkah.

Apa itu Qwen3.5 VLM?

Qwen3.5 adalah model visi-bahasa asli pertama Alibaba dalam seri Qwen3.5, yang dirancang khusus untuk membangun agen otonom. Tidak seperti VLM sebelumnya yang diadaptasi dari model teks-saja, Qwen3.5 dibangun dari awal untuk penalaran multimodal dan navigasi UI.

Spesifikasi Utama

Apa yang Membuat Qwen3.5 Istimewa

Arsitektur Mixture of Experts (MoE) berarti hanya sebagian kecil dari parameter model yang aktif untuk setiap masukan. Ini membuat model efisien secara komputasi sambil mempertahankan kapasitas untuk penalaran kompleks di seluruh 397 miliar parameter.

Kemampuan Agen Multimodal Asli membedakan Qwen3.5 dari VLM lainnya:

• Memahami dan menavigasi antarmuka pengguna
• Melakukan penalaran visual pada antarmuka seluler dan web
• Menangani tugas pengodean yang kompleks
• Mendukung aplikasi obrolan dengan pemahaman multimodal

Kasus Penggunaan Ideal

• Pengodean dan Pengembangan Web: Menulis dan men-debug kode dengan konteks visual
• Penalaran Visual: Menganalisis tangkapan layar, foto, dan elemen UI
• Aplikasi Obrolan: Membangun AI percakapan dengan pemahaman multimodal
• Pencarian Kompleks: Mencari di seluruh gambar dan teks secara bersamaan
• Otomatisasi UI: Menavigasi dan berinteraksi dengan antarmuka secara otonom

Program Pengembang NVIDIA: Dapatkan Kunci API Gratis Anda

NVIDIA menyediakan akses gratis ke Qwen3.5 melalui endpoint yang dipercepat GPU mereka. Berikut cara memulainya:

Langkah 1: Bergabung dengan Program Pengembang NVIDIA

1. Kunjungi build.nvidia.com
2. Klik Masuk atau Buat Akun
3. Daftar untuk NVIDIA Developer Program (gratis)
4. Verifikasi alamat email Anda

Langkah 2: Dapatkan Kunci API Anda

1. Setelah masuk, navigasikan ke pengaturan akun Anda
2. Temukan Kunci API atau Kunci API NVIDIA
3. Salin kunci API Anda (dimulai dengan nvapi-)
4. Simpan dengan aman (Anda akan membutuhkannya untuk autentikasi)

Penting

Langkah 3: Uji Akses Anda

Anda dapat menguji Qwen3.5 langsung di browser Anda di build.nvidia.com/qwen/qwen3.5-397b-a17b. Ini memungkinkan Anda bereksperimen dengan prompt dan mengevaluasi model dengan data Anda sendiri sebelum menulis kode apa pun.

Panggilan API Qwen3.5 Pertama Anda

Sekarang mari kita buat panggilan API pertama Anda ke Qwen3.5. API ini kompatibel dengan format OpenAI, sehingga mudah diintegrasikan ke dalam aplikasi yang sudah ada.

Panggilan API Dasar

import requests

# Konfigurasi
invoke_url = "https://integrate.api.nvidia.com/v1/chat/completions"
api_key = "KUNCI_API_NVIDIA_ANDA"  # Ganti dengan kunci API Anda

headers = {
    "Authorization": f"Bearer {api_key}",
    "Accept": "application/json",
}

# Payload - permintaan teks-saja sederhana
payload = {
    "messages": [
        {
            "role": "user",
            "content": "Apa saja fitur utama Qwen3.5 VLM?"
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
    "temperature": 0.7,
}

# Lakukan permintaan
session = requests.Session()
response = session.post(invoke_url, headers=headers, json=payload)
response.raise_for_status()

# Cetak respons
result = response.json()
print(result['choices'][0]['message']['content'])

Membuat Permintaan Multimodal (Dengan Gambar)

Untuk menggunakan kemampuan visi Qwen3.5, sertakan data gambar dalam permintaan Anda:

import requests
import base64

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

# Kodekan gambar Anda
image_base64 = encode_image("screenshot.png")

invoke_url = "https://integrate.api.nvidia.com/v1/chat/completions"
api_key = "KUNCI_API_NVIDIA_ANDA"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Accept": "application/json",
}

# Permintaan multimodal dengan gambar
payload = {
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_base64}"}
                },
                {
                    "type": "text",
                    "text": "Apa yang Anda lihat pada gambar ini? Jelaskan elemen UI-nya."
                }
            ]
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
}

response = requests.post(invoke_url, headers=headers, json=payload)
result = response.json()
print(result['choices'][0]['message']['content'])

Contoh Kode dalam Python dan JavaScript

Python: Contoh Integrasi Lengkap

import os
import requests
from requests.exceptions import RequestException

class QwenClient:
    """Klien Python untuk API Qwen3.5"""

    def __init__(self, api_key=None):
        self.api_key = api_key or os.getenv("NVIDIA_API_KEY")
        self.endpoint = "https://integrate.api.nvidia.com/v1/chat/completions"
        self.model = "qwen/qwen3.5-397b-a17b"

    def chat(self, message, system_prompt=None, **kwargs):
        """Kirim pesan obrolan ke Qwen3.5"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        messages = []
        if system_prompt:
            messages.append({"role": "system", "content": system_prompt})
        messages.append({"role": "user", "content": message})

        payload = {
            "messages": messages,
            "model": self.model,
            "max_tokens": kwargs.get("max_tokens", 2048),
            "temperature": kwargs.get("temperature", 0.7),
            "top_p": kwargs.get("top_p", 0.9),
        }

        # Aktifkan mode berpikir jika diminta
        if kwargs.get("thinking", False):
            payload["chat_template_kwargs"] = {"thinking": True}

        try:
            response = requests.post(
                self.endpoint,
                headers=headers,
                json=payload,
                timeout=kwargs.get("timeout", 60)
            )
            response.raise_for_status()
            return response.json()
        except RequestException as e:
            return {"error": str(e)}

    def chat_with_image(self, message, image_path, **kwargs):
        """Kirim pesan obrolan dengan gambar ke Qwen3.5"""
        import base64

        with open(image_path, "rb") as f:
            image_base64 = base64.b64encode(f.read()).decode("utf-8")

        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        payload = {
            "messages": [{
                "role": "user",
                "content": [
                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}},
                    {"type": "text", "text": message}
                ]
            }],
            "model": self.model,
            "max_tokens": kwargs.get("max_tokens", 2048),
            "temperature": kwargs.get("temperature", 0.7),
        }

        response = requests.post(self.endpoint, headers=headers, json=payload)
        response.raise_for_status()
        return response.json()


# Contoh penggunaan
client = QwenClient(api_key="KUNCI_API_NVIDIA_ANDA")

# Obrolan teks-saja
result = client.chat("Jelaskan arsitektur Mixture of Experts secara sederhana")
print(result['choices'][0]['message']['content'])

# Obrolan multimodal
result = client.chat_with_image(
    "Elemen UI apa yang ada di tangkapan layar ini?",
    "screenshot.png"
)
print(result['choices'][0]['message']['content'])

JavaScript/Node.js: Contoh Integrasi Lengkap

const axios = require('axios');

class QwenClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.endpoint = 'https://integrate.api.nvidia.com/v1/chat/completions';
    this.model = 'qwen/qwen3.5-397b-a17b';
  }

  async chat(message, options = {}) {
    const { systemPrompt, temperature = 0.7, maxTokens = 2048, thinking = false } = options;

    const messages = [];
    if (systemPrompt) {
      messages.push({ role: 'system', content: systemPrompt });
    }
    messages.push({ role: 'user', content: message });

    const payload = {
      messages,
      model: this.model,
      temperature,
      max_tokens: maxTokens,
      ...(thinking && { chat_template_kwargs: { thinking: true } })
    };

    try {
      const response = await axios.post(this.endpoint, payload, {
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        timeout: 60000
      });

      return response.data;
    } catch (error) {
      console.error('Kesalahan API:', error.response?.data || error.message);
      throw error;
    }
  }

  async chatWithImage(message, imageBase64, options = {}) {
    const { temperature = 0.7, maxTokens = 2048 } = options;

    const payload = {
      messages: [{
        role: 'user',
        content: [
          { type: 'image_url', image_url: { url: `data:image/png;base64,${imageBase64}` } },
          { type: 'text', text: message }
        ]
      }],
      model: this.model,
      temperature,
      max_tokens: maxTokens
    };

    const response = await axios.post(this.endpoint, payload, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  }
}

// Penggunaan
const client = new QwenClient(process.env.NVIDIA_API_KEY);

// Obrolan teks
const result = await client.chat('Apa keuntungan dari arsitektur MoE?');
console.log(result.choices[0].message.content);

// Dengan mode berpikir diaktifkan
const deepResult = await client.chat('Jelaskan bagaimana penalaran bekerja pada LLM', {
  thinking: true
});
console.log(deepResult.choices[0].message.content);

Fitur Lanjutan: Mode Berpikir dan Pemanggilan Alat

Mode Berpikir

Qwen3.5 mendukung mode "berpikir" tingkat lanjut yang memungkinkan model menunjukkan proses penalarannya. Ini sangat berguna untuk tugas pemecahan masalah yang kompleks.

payload = {
    "messages": [{"role": "user", "content": "Selesaikan ini langkah demi langkah: Jika sebuah kereta menempuh 120km dalam 2 jam, berapa kecepatannya?"}],
    "model": "qwen/qwen3.5-397b-a17b",
    "chat_template_kwargs": {"thinking": True},
    "max_tokens": 4096,
}

response = session.post(invoke_url, headers=headers, json=payload)
result = response.json()
print(result['choices'][0]['message']['content'])

Pemanggilan Alat

Qwen3.5 mendukung pemanggilan fungsi melalui alat yang kompatibel dengan OpenAI. Ini memungkinkan Anda membangun aplikasi agen yang dapat menjalankan tindakan nyata.

import json

# Definisikan alat yang akan digunakan model
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Dapatkan cuaca saat ini untuk suatu lokasi",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "Nama kota"}
                },
                "required": ["location"]
            }
        }
    }
]

payload = {
    "messages": [
        {"role": "user", "content": "Bagaimana cuaca di Tokyo?"}
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "tools": tools,
    "tool_choice": "auto"
}

response = session.post(invoke_url, headers=headers, json=payload)
result = response.json()

# Periksa apakah model ingin memanggil alat
if 'tool_calls' in result['choices'][0]['message']:
    tool_call = result['choices'][0]['message']['tool_calls'][0]
    print(f"Model ingin memanggil: {tool_call['function']['name']}")
    print(f"Argumen: {tool_call['function']['arguments']}")

Memahami Batas Kecepatan dan Harga

Tingkat Gratis Saat Ini (NVIDIA Developer Program)

Apa Artinya Bagi Anda

• Tidak diperlukan kartu kredit: Cukup daftar untuk NVIDIA Developer Program gratis
• Dipercepat GPU: Permintaan dijalankan di GPU NVIDIA Blackwell
• Siap produksi: Endpoint yang sama digunakan untuk beban kerja produksi

Penskalaan ke Produksi

Ketika Anda siap untuk beralih dari tingkat gratis:

1. NVIDIA NIM: Terapkan model dalam wadah di mana saja (cloud, on-premises, hibrida)
2. NeMo: Sesuaikan model untuk domain spesifik Anda
3. Dukungan perusahaan: Hubungi NVIDIA untuk infrastruktur khusus

Penyebaran Produksi dengan NVIDIA NIM

NVIDIA NIM (NVIDIA Inference Microservices) memudahkan untuk membawa Qwen3.5 dari pengembangan ke produksi.

Apa itu NIM?

NIM menyediakan wadah yang sudah dibuat sebelumnya dan dioptimalkan untuk inferensi AI. Setiap layanan mikro NIM mengemas:

• Model dengan optimasi kinerja
• API standar (kompatibel dengan OpenAI)
• Fleksibilitas penyebaran (cloud, on-premises, edge)

Menerapkan Qwen3.5 dengan NIM

# Tarik wadah NIM Qwen3.5
docker pull nvcr.io/nim/qwen/qwen3.5-397b-a17b:latest

# Jalankan wadah
docker run --gpus all --rm -p 8000:8000 \
  -e NVIDIA_API_KEY=$NVIDIA_API_KEY \
  nvcr.io/nim/qwen/qwen3.5-397b-a17b:latest

Sekarang model Anda berjalan secara lokal di http://localhost:8000/v1/chat/completions.

Manfaat NIM

• Penyebaran di mana saja: Jalankan on-premises, di cloud, atau hibrida
• Kinerja yang dioptimalkan: Disesuaikan untuk inferensi GPU NVIDIA
• API yang konsisten: Antarmuka yang kompatibel dengan OpenAI
• Skalabel: Skala dari pengembangan ke produksi dengan mulus

Kustomisasi dengan NVIDIA NeMo

Untuk aplikasi spesifik domain, Anda dapat melakukan fine-tuning Qwen3.5 menggunakan NVIDIA NeMo.

Kemampuan Kerangka Kerja NeMo

• Fine-tuning throughput tinggi: Pelatihan asli PyTorch
• Dukungan LoRA: Kustomisasi efisien memori
• Pelatihan multinode: Dukungan Slurm dan Kubernetes
• Integrasi Hugging Face: Pelatihan langsung pada checkpoint yang sudah ada

Contoh: Fine-tuning untuk VQA Medis

NVIDIA menyediakan tutorial teknis untuk fine-tuning Qwen3.5 pada dataset radiologi untuk Visual Question Answering medis. Ini menunjukkan bagaimana mengadaptasi model untuk domain khusus seperti perawatan kesehatan.

Kesimpulan

Qwen3.5 merepresentasikan peluang menarik untuk menggunakan model AI multimodal mutakhir tanpa biaya melalui platform pengembang NVIDIA. Dengan arsitektur MoE 397 miliar parameter, kemampuan visi asli, dan akses API gratis, ini adalah pilihan yang sangat baik untuk:

• Membangun agen AI multimodal
• Mengembangkan aplikasi penalaran visual
• Membuat asisten pengodean dengan konteks visual
• Mengotomatiskan tugas navigasi UI

Memulainya sangat mudah: daftar untuk NVIDIA Developer Program, dapatkan kunci API Anda, dan mulailah membangun.

Jika Anda membangun aplikasi yang terintegrasi dengan Qwen3.5 atau API AI lainnya, Apidog menyediakan infrastruktur pengujian yang Anda butuhkan. Uji integrasi API Anda, validasi respons, kelola variabel lingkungan, dan otomatiskan alur kerja pengujian Anda dengan platform komprehensif Apidog.

FAQ

Apakah Qwen3.5 benar-benar gratis untuk digunakan?

Ya, NVIDIA menyediakan akses gratis ke endpoint yang dipercepat GPU Qwen3.5 melalui Program Pengembang mereka. Tidak diperlukan kartu kredit. Cukup daftar di build.nvidia.com untuk mendapatkan kunci API Anda.

Apa yang membuat Qwen3.5 berbeda dari VLM lainnya?

Qwen3.5 dibangun khusus untuk agen otonom, tidak diadaptasi dari model teks-saja. Arsitektur Mixture of Experts-nya (total 397B, aktif 17B) menyediakan penalaran yang kuat sementara tetap efisien secara komputasi. Ini sangat baik dalam tugas navigasi UI dan penalaran visual.

Dapatkah saya menggunakan Qwen3.5 untuk proyek komersial?

Periksa ketentuan lisensi saat ini di platform NVIDIA. Untuk penggunaan produksi, pertimbangkan NVIDIA NIM untuk penyebaran atau hubungi NVIDIA mengenai opsi perusahaan.

Apa perbedaan antara tingkat gratis dan NIM?

Tingkat gratis (Program Pengembang) menggunakan endpoint yang di-host oleh NVIDIA. NIM memungkinkan Anda menyebarkan model sendiri menggunakan wadah, baik on-premises, di cloud Anda, atau lingkungan hibrida. NIM dirancang untuk penyebaran skala produksi.

Bagaimana cara menangani pembatasan kecepatan?

Tingkat gratis memiliki batas kecepatan tertentu. Untuk batas yang lebih tinggi, pertimbangkan untuk meningkatkan ke akses produksi melalui NVIDIA NIM atau menghubungi NVIDIA mengenai opsi perusahaan.

Dapatkah saya melakukan fine-tuning Qwen3.5?

Ya! Kerangka kerja NVIDIA NeMo menyediakan alat untuk melakukan fine-tuning Qwen3.5 pada data spesifik domain Anda. Ini termasuk LoRA untuk kustomisasi efisien memori dan dukungan multinode untuk pelatihan skala besar.