Cara Menjalankan Bonsai 27B Secara Lokal di Memori 8GB

Catatan: Bonsai 2 27B kini tersedia, berbasis Qwen3.8 27B

Qwen3.6-27B menjadi pilihan populer untuk menjalankan model penalaran dan coding yang andal secara lokal. Model ini cepat dan bertenaga, namun model 27 miliar parameter penuh tetap membutuhkan memori yang signifikan. 

Menggunakan kuantisasi konvensional dapat menurunkan kebutuhan tersebut, namun bisa juga menyebabkan penurunan performa yang terasa.

Sumber: prism-ml/Bonsai-27B-gguf

Prism ML mengambil pendekatan berbeda dengan Bonsai 27B, versi 1-bit Qwen3.6-27B yang terkompresi tinggi. 

Menurut Prism ML, Bonsai mempertahankan hampir 90% performa tolok ukur model asli sekaligus mengurangi bobot model menjadi sekitar 3,9 GB. 

Ini memungkinkan Anda bereksperimen dengan model penalaran kelas 27B pada perangkat konsumen yang jauh lebih mudah diakses.

Dalam tutorial ini, saya akan menggunakan model 1-bit Bonsai-27B-Q1_0.gguf dan skrip setup kustom dari Prism ML. Skrip ini otomatis mengunduh model, memilih runtime prebuilt yang kompatibel, dan mengonfigurasinya untuk perangkat keras yang tersedia. 

Saya kemudian akan menguji Bonsai dari command line, menjalankan antarmuka web lokalnya, mengaksesnya melalui API yang kompatibel dengan OpenAI, dan menghubungkannya ke agen coding Pi.

Apa yang Spesial dari Bonsai 27B?

Yang membuat Bonsai 27B menarik adalah bahwa ini bukan sekadar model Qwen yang dikuantisasi secara konvensional. 

Sebagian besar model GGUF lokal dikompresi setelah pelatihan dengan menurunkan presisi numerik model yang ada. 

Bonsai mengambil pendekatan yang lebih agresif dengan menyesuaikan model di sekitar bobot biner, memungkinkan sebagian besar jaringan beroperasi menggunakan nilai yang mendekati −1 atau +1.

Ini penting karena menjalankan model bahasa besar sering kali dibatasi oleh kapasitas memori dan bandwidth memori, bukan hanya kekuatan komputasi mentah. 

Menurunkan presisi bobot mengurangi jumlah data yang harus disimpan dan dipindahkan selama inferensi. 

Dengan runtime yang dioptimalkan, ini dapat membuat model 27B besar menjadi praktis pada perangkat konsumen yang biasanya kesulitan memuat atau menjalankannya.

Sumber: prism-ml/Bonsai-27B-gguf · Hugging Face 

Bonsai juga mempertahankan kapabilitas di luar sekadar chat dasar. 

Model ini mendukung penalaran, coding, pemanggilan alat terstruktur, prompt konteks panjang, dan alur kerja agen.

Model ini juga dapat berjalan di balik API yang kompatibel dengan OpenAI, sehingga lebih mudah terhubung dengan agen coding, sistem retrieval, alat otomasi, dan aplikasi yang sudah mendukung endpoint bergaya OpenAI.

Namun, Bonsai tidak boleh diperlakukan identik dengan model Qwen3.6-27B presisi penuh. 

Kompresi ekstrem tetap melibatkan trade-off dan dapat memengaruhi kepatuhan instruksi, pemilihan alat, konsistensi penalaran, dan kualitas keluaran secara berbeda di berbagai tugas. 

Keunggulan utamanya adalah keseimbangan yang ditawarkan: kapabilitas model besar dengan kebutuhan perangkat keras yang jauh lebih rendah.

Prasyarat Menjalankan Bonsai 27B Secara Lokal

Sebelum memulai, pastikan sistem Anda memiliki:

• Setidaknya 8 GB RAM sistem, meski 16 GB atau lebih dianjurkan
• Sekitar 8 GB ruang penyimpanan kosong untuk model, runtime, dan file pendukung
• Git untuk mengkloning repositori demo Bonsai
• Sistem operasi yang didukung, seperti Linux, Windows, atau macOS
• GPU NVIDIA, AMD, kompatibel Vulkan, atau Apple Silicon untuk inferensi yang lebih cepat

GPU khusus bersifat opsional karena Bonsai juga dapat berjalan menggunakan CPU. 

Namun, inferensi berbasis CPU umumnya lebih lambat, terutama saat model menghasilkan respons penalaran yang panjang.

Untuk panduan ini, saya menggunakan satu NVIDIA RTX 5070 Ti dengan 16 GB VRAM. 

Ini menyediakan cukup memori untuk memuat bobot model sekitar 3,9 GB sepenuhnya di GPU dan menyisakan memori tambahan untuk KV cache, aktivasi model, dan overhead runtime.

Namun, VRAM yang tersedia juga menentukan seberapa besar konteks yang dapat Anda gunakan. 

Meskipun Bonsai 27B mendukung percakapan melebihi 256K token, memuat konteks pelatihan lengkapnya dapat mengonsumsi banyak memori tambahan dan mungkin menguras sistem dengan RAM atau VRAM terbatas. 

Karena itu, Prism ML menggunakan ukuran konteks default yang peka memori alih-alih secara otomatis mengalokasikan jendela 262K token lengkap.

Dalam tutorial ini, kita akan mulai menggunakan jendela konteks 8.192 token untuk pengujian command line. Lalu kita akan meningkatkannya saat meluncurkan server, tergantung memori yang tersedia. 

Jendela konteks yang lebih kecil sudah cukup untuk sebagian besar tugas coding dan chat serta memberikan waktu mulai yang lebih cepat dengan penggunaan memori lebih rendah.

Langkah 1: Unduh dan Instal Bonsai 27B

Buka terminal dan kloning repositori demo Bonsai resmi:

git clone https://github.com/PrismML-Eng/Bonsai-demo.git
cd Bonsai-demoDidukung oleh

Repositori ini menyertakan skrip untuk mengunduh model, mendeteksi perangkat keras Anda, memilih binary runtime yang benar, menjalankan model dari terminal, dan meluncurkan server lokal.

Jalankan perintah setup berikut:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_OPENWEBUI=0 \
BONSAI_CODE_INTERPRETER=0 \
./setup.shDidukung oleh

Selama setup, Anda mungkin diminta memasukkan token akses Hugging Face. 

Ini opsional untuk file model publik, jadi Anda bisa melewatinya dengan menekan Enter. 

Namun, menggunakan token dapat membantu menghindari batas unduhan anonim.

Skrip mengunduh sekitar 7,15 GB file, termasuk:

• Model bahasa Bonsai-27B-Q1_0.gguf
• multimodal projector (mmproj)
• File tambahan terkait D-Spark
• Binary runtime prebuilt yang telah diuji untuk perangkat keras Anda

Mengatur BONSAI_FAMILY=bonsai memilih model Bonsai 1-bit yang ringkas alih-alih versi ternary yang lebih besar.

Opsi berikut menonaktifkan dua lingkungan tambahan:

BONSAI_OPENWEBUI=0
BONSAI_CODE_INTERPRETER=0Didukung oleh

Open WebUI tidak diperlukan untuk tutorial ini karena binary server yang disertakan sudah menyediakan antarmuka chat berbasis browser yang ringan.

 Lingkungan code-interpreter juga tidak diperlukan untuk setup lokal dasar.

Selama instalasi, skrip setup secara otomatis:

• Menginstal paket Linux yang diperlukan
• Membuat lingkungan virtual Python
• Mengunduh file model Bonsai 27B
• Mengunduh runtime prebuilt yang sesuai
• Mendeteksi backend CPU atau GPU yang tersedia
• Mengonfigurasi proyek untuk perangkat keras Anda

Setup otomatis ini sangat berguna karena Anda tidak perlu mengompilasi llama.cpp secara manual atau memilih binary CUDA, ROCm, Vulkan, Metal, atau CPU sendiri.

Saya merekomendasikan tutorial llama.cpp jika Anda membutuhkan pengantar cepat. 

Langkah 2: Uji Bonsai 27B dari CLI

Setelah instalasi, uji model langsung dari terminal menggunakan antarmuka command-line llama.cpp yang disertakan:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_CTX=8192 \
./scripts/run_llama.sh \
-p "Create a simple Python function that calculates compound interest."Didukung oleh

Perintah ini:

• Memilih keluarga model Bonsai 1-bit
• Memuat model 27B
• Mengatur jendela konteks ke 8.192 token
• Memulai terminal interaktif llama.cpp
• Mengirim permintaan bunga majemuk sebagai prompt pertama

Peluncuran pertama mungkin memerlukan beberapa saat saat model dimuat ke memori sistem atau VRAM GPU. 

Setelah siap, terminal menampilkan model aktif, informasi build, dan perintah yang tersedia sebelum menghasilkan respons.

Seperti terlihat pada keluaran, Bonsai terlebih dahulu menghasilkan proses penalarannya lalu memberikan contoh Python lengkap, termasuk fungsi, instruksi penggunaan, dan hasil perhitungan. 

Setelah respons pertama, sesi tetap terbuka, memungkinkan Anda memasukkan prompt tambahan tanpa memulai ulang model.

Langkah 3: Mulai Server Bonsai

Pertama, tekan Ctrl+C untuk menutup sesi CLI interaktif dari langkah sebelumnya.

Kemudian jalankan server Bonsai lokal:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_CTX=100000 \
./scripts/start_llama_server.sh \
--alias bonsai-27b \
--host 0.0.0.0 \
--port 8910Didukung oleh

Perintah ini:

• Memuat model Bonsai 27B 1-bit
• Mengalokasikan jendela konteks 100.000 token
• Mendaftarkan model dengan nama bonsai-27b
• Menjalankan server pada port 8910
• Membuatnya dapat diakses dari mesin lokal dan perangkat lain di jaringan yang sama

Jendela konteks 100.000 token membutuhkan memori jauh lebih banyak daripada uji CLI 8.192 token sebelumnya. Kurangi BONSAI_CTX jika model gagal mulai atau sistem Anda kehabisan RAM atau VRAM.

Karena --host 0.0.0.0 mengekspos server ke jaringan lokal Anda, hindari menggunakannya pada jaringan yang tidak tepercaya. Untuk akses lokal saja, gantikan dengan:

--host 127.0.0.1Didukung oleh

Biarkan terminal ini tetap terbuka saat menggunakan model. Menutupnya akan menghentikan server.

Server Bonsai menyediakan:

• Antarmuka web lokal yang ringan
• Sebuah API yang kompatibel dengan OpenAI
• Respons streaming
• Pemanggilan alat terstruktur
• Kontrol penalaran spesifik model

API yang kompatibel dengan OpenAI tersedia di:

http://127.0.0.1:8910/v1Didukung oleh

Langkah 4: Uji Bonsai 27B menggunakan CURL

Buka terminal kedua dan kirim permintaan ke endpoint chat-completions:

curl http://127.0.0.1:8910/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bonsai-27b",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function for loading and validating a CSV file."
      }
    ],
    "max_tokens": 1000
  }'Didukung oleh

Permintaan menggunakan struktur yang sama seperti OpenAI Chat Completions API:

• model memilih alias server yang dibuat sebelumnya
• messages berisi percakapan
• max_tokens membatasi jumlah token yang dihasilkan

API mengembalikan JSON dengan kecepatan sekitar 95 token per detik, tetapi respons berhenti pada batas 1.000 token, jadi tingkatkan "max_tokens" menjadi 3000 untuk jawaban lengkap sebelum menghubungkan Bonsai ke aplikasi, agen, atau program Python.

Langkah 5: Uji Web UI Bonsai 27B

Buka alamat berikut di browser Anda:

http://127.0.0.1:8910Didukung oleh

Antarmuka bawaan llama.cpp memungkinkan Anda mengobrol dengan Bonsai, mengunggah file, dan menyesuaikan upaya penalaran dari Off hingga Max.

Uji dengan prompt coding seperti:

Create a Python command-line application that converts CSV files to JSON.Didukung oleh

Bonsai menghasilkan skrip Python lengkap dengan kecepatan sekitar 92 token per detik pada RTX 5070 Ti saya. 

Saya juga memintanya membuat situs web portofolio pribadi. 

Meskipun kodenya berfungsi, saya tidak puas dengan UI yang dihasilkan, karena desainnya terlihat sederhana dan generik. 

Ini menunjukkan Bonsai mampu menghasilkan kode fungsional, tetapi mungkin memerlukan prompt yang lebih rinci dan beberapa revisi untuk membuat antarmuka yang rapi.

Langkah 6: Instal Agen Coding Pi

Pi adalah agen coding berbasis terminal yang kita gunakan untuk menguji Bonsai 27B dalam alur kerja coding agen yang nyata melalui API lokal yang kompatibel dengan OpenAI.

Buka terminal baru dan instal agen coding Pi:

curl -fsSL https://pi.dev/install.sh | shDidukung oleh

Saat diminta, tekan Enter atau ketik y untuk melanjutkan instalasi default.

Pastikan Pi telah terinstal dengan sukses:

pi --versionDidukung oleh

Pada saat pengujian, versi yang terinstal adalah:

0.82.0Didukung oleh

Langkah 7: Tambahkan Bonsai 27B ke Pi

Pastikan server Bonsai masih berjalan, lalu buka terminal baru dan buat direktori konfigurasi Pi:

mkdir -p ~/.pi/agentDidukung oleh

Buat file konfigurasi model kustom:

nano ~/.pi/agent/models.jsonDidukung oleh

Tempelkan konfigurasi berikut:

{
  "providers": {
    "bonsai-local": {
      "baseUrl": "http://127.0.0.1:8910/v1",
      "api": "openai-completions",
      "apiKey": "local",
      "compat": {
        "supportsDeveloperRole": false,
        "supportsReasoningEffort": false
      },
      "models": [
        {
          "id": "bonsai-27b",
          "name": "Bonsai 27B Local",
          "reasoning": true,
          "input": ["text"],
          "contextWindow": 100000,
          "maxTokens": 50000,
          "cost": {
            "input": 0,
            "output": 0,
            "cacheRead": 0,
            "cacheWrite": 0
          }
        }
      ]
    }
  }
}Didukung oleh

Konfigurasi ini menghubungkan Pi ke endpoint lokal yang kompatibel dengan OpenAI, mendaftarkan model sebagai Bonsai 27B Local, dan menyamakan pengaturan konteks 100.000 token pada server.

Simpan dan tutup file:

Ctrl + O
Enter
Ctrl + XDidukung oleh

Pi secara otomatis memuat penyedia model kustom dari ~/.pi/agent/models.json.

Langkah 8: Jalankan Pi dengan Bonsai 27B

Pastikan server Bonsai masih berjalan, lalu buat direktori proyek baru:

mkdir simple-python
cd simple-pythonDidukung oleh

Jalankan Pi menggunakan model Bonsai lokal:

pi --provider bonsai-local --model bonsai-27bDidukung oleh

Masukkan prompt seperti:

Build a simple Python application with a FastAPI backend and a modern, 
responsive web interface that accepts user input, processes it, 
and displays the result.Didukung oleh

Pi mulai bernalar, membuat file proyek, menginstal paket yang diperlukan, dan menghasilkan aplikasi analisis teks dengan backend FastAPI dan frontend responsif.

Saat model berjalan dengan jendela konteks 100.000 token, nvidia-smi menunjukkan penggunaan VRAM sekitar 11,9 GB pada RTX 5070 Ti saya:

Di akhir proses, Pi mengonfirmasi bahwa tugas telah selesai dan menghasilkan ringkasan jelas tentang semua yang telah dilakukan. 

Ini mencakup file yang dibuat, fitur utama aplikasi, pengujian yang dilakukan, dan perintah tepat yang diperlukan untuk menjalankan proyek secara lokal. 

Setelah generasi, Pi merangkum file dan fitur yang dibuatnya. 

Saya menguji backend menggunakan:

curl -s -X POST http://localhost:10100/analyze \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello world! This is a test."}'Didukung oleh

API berfungsi, dan antarmukanya terlihat lebih baik daripada situs web sebelumnya yang dihasilkan melalui web UI dasar. 

Namun, aplikasi tersebut masih belum lengkap: beberapa tombol dan kontrol hilang, dan frontend tidak menampilkan semua statistik yang tersedia dari backend API. 

Ini menunjukkan bahwa Bonsai dapat membangun aplikasi full-stack yang fungsional, namun hasilnya tetap perlu diuji dan dipoles.

Pemikiran Akhir

Dalam pengujian saya, Bonsai 27B masih terasa seperti model yang terkompresi berat. 

Kualitas keluarannya belum sepenuhnya setara dengan Qwen3.6-27B yang dikuantisasi Q4, yang sebelumnya pernah saya uji dan saya anggap lebih andal untuk alur kerja agen coding. 

Versi Q4 membutuhkan lebih banyak memori, tetapi memberikan penalaran yang lebih kuat, generasi kode yang lebih baik, dan hasil yang lebih konsisten.

Meski begitu, Bonsai 27B tetap sangat mumpuni untuk model dengan jejak sekitar 3,8 GB.

Model ini memahami instruksi, membuat file proyek, menjalankan perintah, menguji hasilnya, dan dapat membangun aplikasi fungsional secara lokal. Dalam kategori ukuran ini, ini adalah salah satu model paling mampu yang pernah saya coba.

Untuk pekerjaan agen coding yang serius, saya masih akan memilih versi Q4 dari Qwen3.6-27B, terutama karena RTX 3090 saya memiliki 24 GB VRAM dan dapat menangani model yang lebih besar dengan nyaman. 

Meski demikian, saya sangat menikmati menggunakan Bonsai 27B dan terkesan dengan ekosistem Prism ML yang lebih luas. Setup otomatis, runtime yang dioptimalkan, antarmuka web bawaan, API yang kompatibel dengan OpenAI, dan integrasi agen membuatnya jauh lebih mudah bagi lebih banyak orang untuk menjalankan dan merasakan model penalaran besar secara lokal pada perangkat keras konsumen.