Jalankan Qwen3-Coder-Next Secara Lokal: Vibe Coding Dashboard Analitik

Qwen3-Coder-Next adalah model pemrograman open-weight dari tim Qwen, dibangun untuk agentic programming dan alur kerja pengembang lokal. Model ini menggunakan desain mixture-of-experts yang jarang untuk tetap efisien namun tetap berkinerja kuat pada tolok ukur pemrograman modern dan penggunaan alat, dengan dukungan untuk konteks panjang dan tugas multi-langkah yang kompleks.

Yang membuat Qwen3-Coder-Next sangat menarik adalah betapa kompetitifnya dibandingkan model tertutup papan atas. Evaluasi awal menunjukkan model ini dapat mencapai tingkat kinerja yang mendekati sistem seperti Claude Sonnet 4.5, sekaligus tetap bisa dijalankan secara lokal dengan kendali penuh atas penyiapan, privasi, dan kecepatan Anda, tanpa bergantung pada API hosted yang mahal.

Sumber: Qwen/Qwen3-Coder-Next

Dalam tutorial ini, kita akan membangun llama.cpp dari sumber, menjalankan Qwen3-Coder-Next secara lokal menggunakan server inferensi llama.cpp, lalu menghubungkannya ke Qwen Code CLI. Terakhir, kita akan melakukan vibe coding sebuah dashboard analitik sederhana.

Prasyarat Perangkat Keras dan Perangkat Lunak Qwen3-Coder-Next

Sebelum membangun dan menjalankan Qwen3-Coder-Next secara lokal, Anda memerlukan setelan pengembangan Linux yang berfungsi dengan alat build standar yang dibutuhkan untuk mengompilasi llama.cpp dan menjalankan model GGUF.

Selain paket sistem, pastikan Anda juga memiliki:

• Python (>= 3.11) untuk skrip pendukung dan alur kerja lokal
• Node.js + npm (Node 20+) untuk memasang Qwen Code CLI
• Driver GPU NVIDIA yang benar
• CUDA Toolkit yang dikonfigurasi untuk akselerasi GPU penuh

Mulailah dengan memperbarui sistem Anda dan memasang dependensi inti:

sudo apt-get update
sudo apt-get install -y build-essential cmake curl git libcurl4-openssl-devDidukung oleh

Jika Anda berencana menggunakan akselerasi CUDA, pastikan GPU NVIDIA Anda terdeteksi dengan benar:

nvidia-smiDidukung oleh

Dalam kasus kami, kami menggunakan NVIDIA RTX 3090 dengan VRAM 24GB. Karena Qwen3-Coder-Next membutuhkan lebih banyak memori daripada itu untuk kuantisasi yang lebih besar, bobot model yang tersisa akan otomatis dialihkan ke RAM sistem, sehingga model tetap dapat berjalan secara lokal dengan kinerja yang baik.

Agar Qwen3-Coder-Next berjalan mulus, perangkat keras Anda sebaiknya memenuhi target memori perkiraan berikut:

• 46GB RAM / VRAM / memori terpadu direkomendasikan untuk inferensi GGUF 4-bit.
• ~85GB memori dibutuhkan untuk varian 8-bit.

Jika Anda tidak memiliki 46GB yang tersedia, Anda masih dapat menjalankan versi kuantisasi yang lebih kecil (seperti 3-bit).

Aturan praktis sederhananya adalah:

Disk + RAM + VRAM ≥ ukuran kuantisasi

Jika seluruh kuantisasi muat dalam memori, Anda dapat mengharapkan kinerja lokal yang cepat. Jika tidak, model tetap akan berjalan dengan offloading, tetapi inferensinya akan lebih lambat.

Memasang llama.cpp dengan Dukungan CUDA

Sebelum menjalankan Qwen3-Coder-Next secara lokal, kita memerlukan mesin inferensi yang cepat. Opsi paling populer saat ini adalah llama.cpp, yang menyediakan inferensi GGUF yang ringan dan server lokal yang mudah dijalankan.

Jika Anda menginginkan penyiapan paling cepat, llama.cpp menawarkan biner prabangun untuk macOS, Linux, dan Windows (termasuk build berkemampuan CUDA). Anda dapat mengunduhnya langsung dari halaman rilis GitHub resmi: Release b7936 · ggml-org/llama.cpp. 

Dengan pemasangan prabangun, Anda dapat langsung menjalankan alat CLI llama.cpp atau memulai server inferensi tanpa mengompilasi apa pun sendiri.

Dalam tutorial ini, kita akan membangun llama.cpp secara manual alih-alih mengandalkan biner prabangun karena beberapa alasan penting:

• Pembaruan dan perbaikan bug terbaru dari repositori GitHub
• Dukungan CUDA penuh yang dioptimalkan untuk sistem Linux
• Kinerja lebih baik yang disetel untuk GPU dan lingkungan spesifik Anda
• Diperlukan untuk format kuantisasi yang lebih baru dan peningkatan terbaru dalam kualitas keluaran model

Mari mulai dengan mengunduh kode sumber resmi llama.cpp langsung dari GitHub. Ini memastikan kita menggunakan versi terbaru, termasuk peningkatan CUDA dan perbaikan bug terkini:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cppDidukung oleh

Pada titik ini, Anda seharusnya berada di dalam direktori llama.cpp, yang berisi semua yang dibutuhkan untuk membangun proyek dari awal.

Selanjutnya, kita perlu mengonfigurasi sistem build menggunakan CMake. Langkah ini menghasilkan berkas build yang diperlukan dan mengaktifkan akselerasi GPU melalui CUDA:

cmake /workspace/llama.cpp -B /workspace/llama.cpp/build -DGGML_CUDA=ON -DBUILD_SHARED_LIBS=OFFDidukung oleh

Sekarang kita mengompilasi biner server inferensi. Ini adalah komponen yang akan meng-host Qwen3-Coder-Next secara lokal dan membuka endpoint API untuk alat pemrograman dan integrasi CLI:

cmake --build /workspace/llama.cpp/build -j --clean-first --target llama-serverDidukung oleh

Setelah proses build selesai, executable yang dikompilasi disimpan di dalam direktori build/bin/. Untuk memudahkan menjalankannya langsung dari folder proyek utama, Anda dapat menyalinnya seperti ini:

cp /workspace/llama.cpp/build/bin/llama-server /workspace/llama.cpp/llama-serverDidukung oleh

Mengunduh Model Qwen3-Coder-Next

Setelah llama.cpp terpasang, langkah berikutnya adalah mengunduh model Qwen3-Coder-Next GGUF dari Hugging Face.

Sebelum mulai, pastikan Anda memiliki instalasi Python terbaru (>= 3.11), karena peralatan dan utilitas transfer Hugging Face bergantung padanya.

Untuk mengunduh berkas GGUF besar secara efisien, kita akan menggunakan klien Hugging Face Hub bersama backend Xet dan transfer berkecepatan tinggi:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transferDidukung oleh

Selanjutnya, aktifkan backend transfer yang dioptimalkan dari Hugging Face:

export HF_HUB_ENABLE_HF_TRANSFER=1Didukung oleh

Sekarang kita dapat mengunduh versi Unsloth dynamic GGUF dari Qwen3-Coder-Next. Dalam tutorial ini, kita akan mengambil kuantisasi UD-Q4_K_XL secara khusus.

Ini adalah pilihan default yang bagus karena memberikan pertukaran yang sangat baik antara:

• Kualitas model (kinerja pemrograman sangat kuat)
• Kecepatan inferensi (cukup cepat untuk alur kerja vibe coding lokal)
• Efisiensi memori (muat di GPU konsumen kelas atas dengan offloading ke RAM)

Format Q4 berarti model dikompresi menjadi presisi 4-bit, sehingga jauh lebih ringan daripada bobot FP16 penuh namun tetap mempertahankan kualitas keluaran yang mengesankan. 

hf download unsloth/Qwen3-Coder-Next-GGUF \
  --local-dir /workspace/models/qwen3-coder-next \
  --include "*UD-Q4_K_XL*"Didukung oleh

Setelah perintah dijalankan, berkas model akan mulai diunduh ke direktori lokal Anda.

Pada jaringan berkecepatan tinggi, ini biasanya hanya memakan waktu beberapa menit. Setelah unduhan selesai, Anda akan memiliki model GGUF yang siap dimuat ke dalam llama-server untuk inferensi lokal.

Menjalankan Server Inferensi Qwen3-Coder-Next

Setelah model GGUF diunduh, kita dapat meluncurkan Qwen3-Coder-Next secara lokal menggunakan backend inferensi llama-server. Ini memulai server API yang kompatibel dengan OpenAI yang dapat dihubungkan oleh alat pemrograman dan CLI.

Jalankan perintah berikut:

./llama-server \
  --model "/workspace/models/qwen3-coder-next/Qwen3-Coder-Next-UD-Q4_K_XL.gguf" \
  --alias "Qwen3-Coder-Next" \
  --host 0.0.0.0 \
  --port 8080 \
  --threads 32 \
  --threads-batch 32 \
  --ctx-size 20000\
  --batch-size  1024\ 
  --ubatch-size 256 \
  --jinja \
  --flash-attn on \
  --temp 0.7 \
  --top-p 0.9 \
  --min-p 0.05 \
  --fit on \
  --swa offDidukung oleh

Penjelasan Argumen Kunci:

• --model: Jalur ke checkpoint GGUF Qwen3-Coder-Next yang diunduh
• --alias: Nama model ramah yang ditampilkan di klien API
• --host 0.0.0.0: Mengekspos server pada semua antarmuka jaringan (berguna untuk akses jarak jauh)
• --port 8080: Menjalankan API inferensi pada port 8080
• --threads 32: Menggunakan 32 thread CPU untuk throughput maksimum
• --threads-batch 32: Memparalelkan pemrosesan batch untuk generasi token yang lebih cepat
• --ctx-size 20000: Menetapkan jendela konteks besar (~20K token) untuk sesi pemrograman panjang
• --batch-size 1024: Meningkatkan pemanfaatan GPU selama inferensi
• --ubatch-size 256: Mengontrol micro-batching untuk kinerja yang lebih mulus
• --jinja: Mengaktifkan pemformatan template chat yang diperlukan untuk model gaya instruksi
• --flash-attn on: Mengaktifkan Flash Attention untuk inferensi konteks panjang yang lebih cepat
• --temp 0.7: Menjaga keluaran tetap fokus namun tetap kreatif untuk vibe coding
• --top-p 0.9: Nucleus sampling untuk keragaman yang seimbang
• --min-p 0.05: Menyaring token berprobabilitas sangat rendah untuk penyelesaian yang lebih bersih
• --fit on: Secara otomatis memuat lapisan ke VRAM dan mengalihkan sisanya ke RAM
• --swa off: Menonaktifkan sliding window attention (lebih baik untuk tugas berkonteks penuh)

Setelah server mulai, biarkan tetap berjalan di jendela terminal tersebut. Lalu, buka tab atau sesi terminal baru untuk menguji API tanpa menghentikan server.

Dari terminal baru, Anda dapat memastikan semuanya berfungsi dengan menanyakan model yang tersedia:

curl http://127.0.0.1:8080/v1/modelsDidukung oleh

Jika server berjalan dengan benar, Anda akan melihat Qwen3-Coder-Next dikembalikan dalam respons, yang berarti endpoint inferensi lokal Anda siap digunakan.

Akses Endpoint API Qwen3-Coder-Next Lokal via Web UI

Setelah server inferensi berjalan, Anda juga dapat berinteraksi dengan Qwen3-Coder-Next langsung melalui Web UI llama.cpp bawaan.

Buka peramban Anda dan kunjungi: http://127.0.0.1:8080.

Ini akan menampilkan antarmuka bergaya ChatGPT sederhana tempat Anda dapat dengan cepat menguji prompt dan memastikan model merespons dengan benar.

Sebagai contoh, mulailah dengan meminta model menghasilkan sesuatu yang praktis, seperti bot trading Python dasar.

Dalam hitungan detik, Anda akan mendapatkan respons lengkap dengan kode yang berfungsi dan langkah implementasi yang jelas.

Yang sangat mengesankan adalah kecepatannya. Pada setelan kami, Qwen3-Coder-Next menghasilkan sekitar 44 token per detik, membuat pemrograman lokal terasa sangat responsif, cukup cepat untuk alur kerja vibe coding real-time.

Memasang dan Menyiapkan Qwen Code CLI

Kini server inferensi lokal berjalan di http://127.0.0.1:8080/v1, kita dapat menghubungkannya ke Qwen Code CLI. Ini memberi Anda asisten pemrograman berbasis terminal yang ringan yang berkomunikasi dengan model Qwen3-Coder-Next lokal Anda melalui API yang kompatibel dengan OpenAI.

Qwen Code CLI adalah alat berbasis Node, jadi Anda memerlukan:

• Node.js 20+
• npm (terpasang otomatis bersama Node.js di Ubuntu/Debian)

Pasang Node.js dari NodeSource (direkomendasikan untuk mendapatkan versi yang tepat):

sudo apt update
sudo apt install -y curl ca-certificates
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejsDidukung oleh

Sekarang pasang Qwen Code CLI secara global:

npm install -g @qwen-code/qwen-code@latestDidukung oleh

Verifikasi pemasangan berhasil:

qwen --version Didukung oleh

0.9.0Didukung oleh

Qwen CLI mengharapkan variabel lingkungan bergaya OpenAI. Kita akan membuat berkas konfigurasi sederhana yang memberi tahu:

• Gunakan API key dummy (karena kita berjalan secara lokal)
• Kirim permintaan ke llama-server pada port 8080
• Gunakan nama model persis yang kita setel dengan --alias

Buat direktori konfigurasi dan berkas .env:

mkdir -p ~/.qwen
cat > ~/.qwen/.env <<'EOF'
OPENAI_API_KEY="dummy"
OPENAI_BASE_URL="http://127.0.0.1:8080/v1"
OPENAI_MODEL="Qwen3-Coder-Next"
EOFDidukung oleh

Sekarang jalankan Qwen Code:

qwen Didukung oleh

Pada titik ini, CLI Anda sudah terhubung ke server Qwen3-Coder-Next lokal Anda, sehingga setiap prompt berjalan secara lokal alih-alih mengenai API hosted.

Vibe Coding Dashboard Analitik menggunakan Qwen3-Coder-Next

Kini semuanya berjalan secara lokal, kita dapat mulai melakukan vibe coding sebuah dashboard analitik sederhana menggunakan Qwen Code CLI.

Pertama, buat folder proyek baru dan masuk ke dalamnya:

mkdir dashboardcd dashboardDidukung oleh

Selanjutnya, jalankan Qwen CLI di dalam direktori ini:

qwenDidukung oleh

Sekarang berikan instruksi yang jelas dan sederhana kepada model, misalnya:

“Bangun dashboard analitik HTML dengan data dummy (penjualan, pengguna, pendapatan, churn), tampilkan kartu KPI, tabel interaktif, dan setidaknya satu bagan, tambahkan filter rentang tanggal dan kategori.”

Dalam hitungan detik, Qwen3-Coder-Next memahami kebutuhan dan memecah tugas menjadi rencana terstruktur sebelum menulis kode.

Setelah daftar ceklis selesai, model menghasilkan dashboard lengkap yang berfungsi dalam sekali jalan, termasuk:

• index.html
• style.css
• script.js

Saat Anda membuka berkas index.html di peramban, Anda akan langsung melihat dashboard modern yang terstruktur dengan baik, gaya yang bersih, kartu KPI, dan metrik placeholder yang realistis. 

Filter, interaksi tabel, dan opsi unduhan semuanya bekerja mulus sejak awal.

Saat Anda menggulir ke bawah, dashboard juga menyertakan data transaksi terperinci dengan sekitar 150 catatan dummy, membuatnya terasa seperti produk analitik yang nyata.

Meskipun tidak menghasilkan setiap visualisasi yang mungkin (misalnya, grafik garis pendapatan dari waktu ke waktu akan menjadi tambahan yang bagus), fakta bahwa model terkuantisasi yang berjalan secara lokal dapat menghasilkan dashboard fungsional pada dasarnya dalam sekali jalan tetap sangat mengesankan. 

Secara keseluruhan, seluruh proses pembuatan hanya memakan waktu beberapa menit dari prompt hingga keluaran yang berfungsi.

Pemikiran Akhir

Sejujurnya: pengalaman saya dengan Qwen3-Coder-Next agak campur aduk.

Di atas kertas, evaluasi menunjukkan model ini seharusnya mendekati model tingkat terdepan seperti Claude Sonnet 4.5, dan gagasan menjalankan model MoE 80B untuk pemrograman secara lokal sungguh menarik. 

Dalam tutorial ini, kita berhasil membangun llama.cpp dengan dukungan CUDA, mengunduh kuantisasi Unsloth GGUF, meluncurkan server inferensi lokal, dan bahkan melakukan vibe coding sebuah dashboard analitik yang berfungsi dalam hitungan menit. Kecepatan dan responsivitas lokalnya mengesankan, terutama untuk setelan open-weight.

Namun dalam praktiknya, saya tidak selalu melihat reliabilitas “setara Sonnet” seperti yang diimplikasikan beberapa tolok ukur. Saya menghabiskan beberapa jam mencoba menggunakan model ini di lingkungan agen yang lebih kompleks seperti opencode, dan saya terus menemui masalah seperti kesalahan alat, generasi yang tidak stabil, dan sesekali keluaran yang berulang.

Menariknya, model terasa jauh lebih andal setelah saya beralih ke alur kerja yang lebih sederhana menggunakan Qwen Code CLI. Dalam pengaturan itu, model berkinerja baik untuk tugas pemrograman langsung, pembuatan prototipe cepat, dan sesi vibe coding. Penggunaannya mulus, cepat, dan benar-benar menyenangkan secara lokal.

Kesimpulan saya: Qwen3-Coder-Next benar-benar layak untuk dieksplorasi, terutama jika Anda menginginkan asisten pemrograman lokal yang andal tanpa API cloud. Namun saya belum merekomendasikannya sebagai pengganti penuh untuk agen pemrograman kelas produksi kecuali Anda siap meluangkan waktu untuk debugging, menyetel setelan llama.cpp, dan mengoptimalkan kinerja untuk perangkat keras Anda.

Jika Anda ingin mempelajari lebih lanjut tentang bekerja dengan AI dalam alur kerja Anda, saya merekomendasikan untuk melihat kursus AI-Assisted Coding for Developers.