Menjalankan Large Language Model di Perangkat Sendiri

Tahun lalu saya menghabiskan $4.200 untuk merakit rig inferensi lokal yang bisa menjalankan model 70B parameter dengan kecepatan yang layak. Seorang kolega melihat setup saya dan langsung bertanya hal yang sudah jelas: 'Kenapa tidak pakai API saja? Itu setara delapan tahun kredit API.' Dia tidak salah soal hitung-hitungannya. Tapi dia keliru soal kalkulasinya.

Menjalankan large language model secara lokal dulunya hanya ranah lab riset dengan klaster GPU berbentuk rack. Sekarang sudah berubah cepat. Hardware konsumen, teknik kuantisasi, dan inference engine yang dioptimalkan membuat model 70B+ bisa dijangkau para hobiis dan tim kecil. Perangkat seperti Tinybox bahkan melangkah lebih jauh: hardware khusus yang dirancang untuk menjalankan model 120B parameter secara offline, tanpa perlu cloud.

Tapi 'bisa' dan 'praktis' itu dua hal yang berbeda. Mari kita bahas apa saja yang sebenarnya dibutuhkan untuk menjalankan model besar secara lokal, kapan hal itu masuk akal, dan kapan lebih baik bayar API.

Kenapa Menjalankan Model Secara Lokal?

Model API, yaitu mengirim data ke penyedia cloud lalu menerima hasilnya, sudah cukup untuk sebagian besar kasus. Lebih sederhana, lebih murah per query di volume rendah, dan selalu memberi akses ke model terbaru. Lalu kenapa ada yang repot-repot melakukan inferensi lokal?

• Privasi dan kepatuhan. Ada data yang tidak boleh keluar dari jaringan Anda. Rekam medis, dokumen hukum, kode proprietary, data keuangan: industri yang diatur regulasi sering punya syarat ketat soal lokasi data. Mengirim catatan pasien ke endpoint API, bahkan yang terenkripsi, bisa melanggar HIPAA. Inferensi lokal menjaga semuanya tetap on-premises.
• Latensi. Panggilan API melibatkan round trip jaringan, potensi antrean, dan rate limit. Inferensi lokal tidak punya latensi jaringan dan Anda tidak pernah mengantre. Untuk aplikasi interaktif seperti asisten coding real-time, terjemahan on-device, dan antarmuka suara, selisih 50ms dan 500ms itulah bedanya antara 'responsif' dan 'lamban'.
• Biaya dalam skala besar. Harga API dihitung per token. Di volume rendah, nilainya kecil. Di volume tinggi, biayanya membengkak parah. Tim yang banyak melakukan code review, analisis dokumen, atau batch processing bisa menghabiskan ribuan dolar per bulan untuk API. Hardware lokal punya biaya tetap. Begitu sudah dibeli, inferensi pada dasarnya gratis.
• Ketersediaan. Cloud API bisa down. Rate limit bisa diberlakukan. Harga bisa berubah tanpa pemberitahuan. Model bisa di-deprecate. Kalau produk Anda bergantung pada API pihak ketiga, Anda tunduk pada keputusan bisnis mereka. Inferensi lokal berarti kemampuan Anda tidak hilang hanya karena server orang lain sedang bermasalah.
• Kebebasan bereksperimen. Penyedia API punya kebijakan penggunaan. Mereka yang menentukan apa yang boleh dan tidak boleh Anda lakukan dengan model. Model lokal tidak punya batasan seperti itu. Anda bisa fine-tune, memodifikasinya, memakainya untuk tujuan apa pun, dan menjalankannya berapa kali pun.

Realita Hardware

Kendala utama untuk inferensi LLM adalah memori, bukan komputasi. Parameter model harus muat di memori (VRAM GPU atau RAM sistem) sebelum Anda bisa melakukan apa pun dengannya. Model 70B parameter dalam floating point 16-bit membutuhkan sekitar 140 GB memori. Jumlah itu lebih besar dari yang ditawarkan GPU konsumen mana pun.

Di sinilah kuantisasi mengubah permainan. Dengan menurunkan presisi bobot model dari 16-bit ke 8-bit, 4-bit, atau bahkan 2-bit, kebutuhan memori bisa turun drastis:

Memory requirements for a 70B parameter model:
FP16 (full precision):  ~140 GB  → requires multiple A100s
INT8 (8-bit quant):     ~70 GB   → requires 2x RTX 4090 (48GB total)
Q4_K_M (4-bit quant):   ~40 GB   → fits on 2x RTX 3090 or 1x A6000
Q2_K (2-bit quant):     ~25 GB   → fits on 1x RTX 4090 (24GB)
For a 120B parameter model:
FP16:                   ~240 GB  → enterprise GPU territory
INT8:                   ~120 GB  → 5x RTX 4090 or purpose-built device
Q4_K_M:                 ~70 GB   → 3x RTX 4090
Q2_K:                   ~40 GB   → 2x RTX 4090

Kuantisasi 4-bit (Q4_K_M di ekosistem llama.cpp) adalah titik manis saat ini. Penurunan kualitasnya terukur, tapi sering masih bisa diterima untuk penggunaan praktis. Kebanyakan orang tidak bisa membedakan output Q4 dari presisi penuh dalam uji buta. Kuantisasi 2-bit cukup terasa dampaknya pada kualitas, terutama untuk tugas yang berat di penalaran, tapi tetap berfungsi untuk aplikasi yang lebih sederhana seperti klasifikasi teks atau ringkasan.

Build Hardware Konsumen

Kalau Anda membangun setup inferensi lokal sendiri, ada tiga jalur dasar, masing-masing dengan profil harga-performa yang berbeda.

Jalur GPU Tunggal

Satu RTX 4090 (24 GB VRAM, sekitar $1.600) bisa menjalankan model terkuantisasi 4-bit hingga sekitar 30B parameter dengan nyaman, atau model 70B dengan kuantisasi 2-bit yang agresif. Untuk model 7B–13B, ini terlalu berlebihan. Anda akan mendapat 40+ token per detik, lebih cepat dari kebanyakan orang membaca. Ini jalur paling mudah: beli GPU, pasang llama.cpp atau Ollama, dan langsung jalan.

Jalur Multi-GPU

Dua GPU atau lebih memungkinkan Anda membagi model ke beberapa perangkat (tensor parallelism). Dua RTX 3090 (total 48 GB VRAM, sekitar $2.200 bekas) bisa dengan nyaman menjalankan model 70B 4-bit. Tantangannya: Anda butuh motherboard dengan jalur PCIe yang cukup dan ruang fisik untuk beberapa GPU ukuran penuh. Sirkulasi udara jadi masalah serius, karena dua GPU 350W dalam satu casing menghasilkan panas yang luar biasa.

Jalur Unified Memory

Mac Apple Silicon dengan unified memory besar menawarkan opsi yang cukup layak. M2 Ultra dengan 192 GB unified memory bisa memuat model 70B presisi penuh sepenuhnya di memori. Kecepatan inferensinya lebih lambat dibanding GPU khusus, mungkin 10-15 token per detik untuk model 70B, tapi kesederhanaannya sulit ditandingi. Tanpa masalah driver, tanpa konfigurasi multi-GPU, tanpa manajemen thermal. Cukup Mac Studio di atas meja yang menjalankan model 70B.

Chip seri M mencapai ini lewat arsitektur unified memory: CPU dan GPU berbagi kumpulan memori yang sama, sehingga tidak ada bottleneck dari penyalinan data antara RAM CPU dan VRAM GPU. Bandwidth memorinya lebih rendah dibanding setup GPU khusus, itulah sebabnya inferensinya lebih lambat. Tapi memiliki 192 GB memori yang bisa dialamati dalam perangkat yang hanya menarik 60 watt benar-benar mengesankan.

Perangkat Inferensi Khusus

Kategori terbaru adalah hardware inferensi lokal yang dibuat khusus, yaitu perangkat dedikasi yang dirancang untuk menjalankan model besar secara efisien. Tujuannya menyelesaikan kerepotan multi-GPU. Alih-alih merangkai GPU konsumen dengan mimpi buruk manajemen kabel, Anda mendapat appliance yang sejak awal dirancang untuk inferensi.

Daya tariknya jelas. Colokkan, arahkan aplikasi Anda ke perangkat itu, dan model Anda langsung jalan. Tanpa konflik driver, tanpa mengatur versi CUDA, tanpa thermal throttling karena ada tiga GPU yang ditempel terlalu dekat. Trade-off-nya adalah biaya. Perangkat khusus biasanya lebih mahal per FLOP dibanding GPU konsumen yang setara. Anda membayar untuk integrasi, keandalan, dan supaya tidak perlu repot men-debug alokasi jalur PCIe.

Untuk perusahaan kecil yang butuh inferensi lokal tapi tidak punya hardware engineer, perangkat ini masuk akal. Untuk hobiis yang senang membangun sesuatu sendiri, rig multi-GPU DIY tetap lebih murah dan lebih fleksibel.

Software Stack

Hardware hanya separuh cerita. Software inferensi berkembang pesat, dan pilihan software yang tepat bisa melipatgandakan throughput di hardware yang sama.

• llama.cpp — Pisau Swiss army untuk inferensi lokal. Ditulis dengan C/C++, berjalan di mana saja dari Raspberry Pi sampai server multi-GPU. Mendukung puluhan arsitektur model dan format kuantisasi. Tidak selalu tercepat, tapi paling portabel dan terus dikembangkan.
• vLLM — Dioptimalkan untuk throughput di GPU NVIDIA. Menggunakan PagedAttention untuk mengelola memori GPU secara efisien, yang sangat meningkatkan inferensi batch. Kalau Anda melayani banyak pengguna dari satu mesin, vLLM biasanya pilihan terbaik.
• Ollama — Pendekatan 'Docker untuk LLM'. Membungkus llama.cpp dalam antarmuka yang ramah pengguna dengan model registry. Jalankan ollama run llama3:70b dan ia akan mengunduh model, mengonfigurasi kuantisasi, lalu mulai melayani. Sangat bagus untuk memulai, tapi kurang bisa dikonfigurasi dibanding llama.cpp mentah.
• MLX — Framework machine learning dari Apple, dioptimalkan untuk Apple Silicon. Kalau Anda memakai Mac seri M, MLX biasanya memberi performa lebih baik dibanding llama.cpp karena memanfaatkan arsitektur unified memory dengan lebih efektif.

# Getting started with Ollama (the easiest path)
# Install: https://ollama.ai
# Run a 7B model (downloads automatically, ~4GB)
$ ollama run mistral
# Run a 70B model (needs ~40GB RAM/VRAM)
$ ollama run llama3:70b-instruct-q4_K_M
# Serve as an API endpoint (OpenAI-compatible)
$ ollama serve
$ curl http://localhost:11434/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{
"model": "mistral",
"messages": [{"role": "user", "content": "Explain TCP handshakes"}]
}'

Perbandingan Biaya yang Jujur

Mari kita hitung yang benar-benar penting. Anggap Anda menjalankan model 70B dan memproses sekitar 1 juta token per hari (kira-kira setara dengan menganalisis 50-100 dokumen atau menangani beberapa ratus percakapan chat).

Cloud API (approximate pricing for 70B-class model):
Input:  $0.50 per million tokens
Output: $1.50 per million tokens
Daily cost: ~$2.00
Monthly cost: ~$60
Yearly cost: ~$720
Local inference (2x RTX 4090 build):
Hardware: $4,200 (one-time)
Electricity: ~$30/month (assuming 700W, 8h/day, $0.15/kWh)
Break-even: ~5.5 years
Local inference (Mac Studio M2 Ultra 192GB):
Hardware: $5,800 (one-time)
Electricity: ~$3/month (60W)
Break-even: ~8 years

Pada 1 juta token per hari, API cloud lebih murah selama bertahun-tahun. Tapi hitungan itu berubah drastis jika volume Anda naik. Pada 10 juta token per hari, API menghabiskan $7.200 per tahun dan hardware lokal balik modal dalam sekitar 7 bulan. Pada 50 juta token per hari, inferensi lokal sudah terbayar dalam hitungan minggu.

Perbandingan biaya ini juga mengabaikan faktor non-finansial: privasi, latensi, ketersediaan, dan kebebasan bereksperimen. Jika salah satunya merupakan kebutuhan (bukan sekadar nice-to-have), perbandingan finansial jadi nomor dua.

Apa yang Hilang dalam Kuantisasi

Kuantisasi memang yang membuat inferensi lokal untuk model besar menjadi mungkin, tapi tidak gratis. Menurunkan presisi berarti sebagian informasi hilang, dan penurunannya tidak merata di setiap tugas.

Dalam pengujian saya, model terkuantisasi 4-bit hampir identik performanya dengan presisi penuh untuk generasi teks, ringkasan, Q&A sederhana, terjemahan, dan generasi kode untuk pola yang umum. Penurunannya terlihat pada penalaran multi-langkah yang kompleks, komputasi matematika, tugas yang memerlukan recall presisi dari data training, dan pengikutan instruksi yang bernuansa.

Implikasi praktisnya: kalau Anda memakai model lokal untuk code completion, ringkasan dokumen, atau AI percakapan, kuantisasi 4-bit sudah sangat memadai. Kalau Anda memakainya untuk penalaran analitis yang kompleks atau tugas di mana perbedaan akurasi kecil itu penting, Anda perlu menguji dengan hati-hati dan mungkin memakai presisi lebih tinggi dengan konsekuensi memori lebih besar atau model yang lebih kecil.

Mengambil Keputusan

Setelah setahun menjalankan model secara lokal, inilah kerangka berpikir saya untuk memutuskan antara inferensi lokal dan cloud:

Gunakan cloud API ketika: Anda butuh kualitas model terbaik yang ada, volumenya rendah sampai sedang, Anda tidak punya keahlian hardware, Anda sering perlu ganti model, atau latensi tidak kritis (beberapa ratus milidetik masih oke).

Jalankan secara lokal ketika: data Anda tidak boleh keluar dari jaringan, Anda butuh latensi sub-100ms yang konsisten, volume token Anda cukup tinggi untuk membenarkan biaya hardware, Anda ingin bereksperimen bebas tanpa biaya per query, atau Anda butuh inferensi yang tidak bergantung pada uptime pihak ketiga.

Lanskapnya berubah cepat. Model makin kecil dan makin efisien. Teknik kuantisasi makin baik. Hardware makin murah. Ambang volume di mana inferensi lokal masuk akal secara finansial turun setiap tahun. Kalau hari ini belum masuk akal untuk Anda, mungkin akan masuk akal dalam delapan belas bulan, dan software stack-nya juga akan makin mudah dipakai selama itu.