LLM on kenji.blog

Panduan Menggunakan llama.cpp dan Pengenalan Kustomisasi dengan C++

Fri, 11 Sep 2026 11:00:00 +0900

Dalam beberapa tahun terakhir, evolusi Large Language Models (LLM) sangat luar biasa, dan jangkauan aplikasinya meluas dari hari ke hari. Namun, menjalankan model dengan miliaran atau puluhan miliar parameter di lingkungan lokal biasanya membutuhkan GPU high-end dengan VRAM yang sangat besar. llama.cpp hadir untuk menerobos “dinding perangkat keras” ini, memungkinkan inferensi LLM secara praktis pada PC umum, Mac, dan bahkan perangkat seperti Raspberry Pi.

Pada artikel ini, kita tidak hanya membahas cara menggunakan alat baris perintah (CLI), tetapi juga menjelaskan secara sangat rinci bagi para engineer mengenai arsitektur ggml yang menjadi teknologi dasarnya, latar belakang matematis dari Transformer dan kuantisasi, serta cara menggunakan API C++ untuk mengintegrasikan dan menyesuaikan LLM ke dalam aplikasi Anda sendiri.

1. Ikhtisar llama.cpp dan ggml

llama.cpp adalah mesin inferensi LLM ringan yang ditulis dalam bahasa C/C++, dikembangkan oleh Georgi Gerganov. Awalnya dibuat dengan tujuan agar model LLaMA dari Meta dapat berjalan cepat di Apple Silicon (Mac M1/M2), tetapi kini telah mendukung berbagai arsitektur dan model.

Fitur terbesarnya adalah merupakan implementasi murni C/C++ tanpa dependensi eksternal. Ia tidak membutuhkan ekosistem besar seperti Python atau PyTorch, dan karena dapat dikompilasi menjadi satu file executable, proses deployment menjadi sangat mudah.

Jantung dari llama.cpp ini adalah library komputasi tensor bernama ggml. ggml dirancang dari nol untuk mengoptimalkan operasi matriks dalam machine learning ke batas maksimal di CPU (dan sebagian GPU).

1.1 Mengapa llama.cpp Cepat?

Pemanfaatan Memory Mapping (mmap): Saat memuat bobot (weights) model ke memori, penggunaan mmap dari OS menghindari pemuatan penuh ke RAM, sehingga menghasilkan startup yang cepat dan hemat memori.
Optimasi Ekstensif Instruksi SIMD: Memanfaatkan set instruksi khusus CPU seperti AVX2, AVX-512, ARM NEON, dan Apple AMX untuk sangat mempercepat perkalian matriks.
Kuantisasi (Quantization): Mengompresi bobot floating-point 16-bit (FP16) menjadi bilangan bulat 4-bit, 5-bit, dan 8-bit untuk mengatasi bottleneck pada bandwidth memori (detail lebih lanjut akan dijelaskan nanti).

2. Latar Belakang Matematis: Transformer dan Kuantisasi (Quantization)

Untuk memahami llama.cpp secara mendalam, kita perlu mengetahui rumus matematika yang dihitungnya dan bagaimana komputasi tersebut diaproksimasi.

2.1 Proses Inferensi Transformer

Model seperti LLaMA menggunakan arsitektur Transformer decoder yang bersifat auto-regressive. Inti dari pembuatan teks adalah mekanisme Self-Attention.

Untuk matriks keadaan tersembunyi (hidden state) $X \in \mathbb{R}^{N \times d}$ sebagai input, Query $Q$, Key $K$, dan Value $V$ dihitung dengan perkalian bersama matriks bobot (weights matrix):

$$ Q = X W_Q, \quad K = X W_K, \quad V = X W_V $$

Di sini, keluaran dari Attention didefinisikan sebagai berikut:

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V $$

Dalam loop inferensi llama.cpp, yang menjadi hambatan (bottleneck) adalah perkalian antara matriks bobot raksasa $W_Q, W_K, W_V$ atau matriks bobot Feed Forward Network (FFN) dengan vektor $X$ (pada fase generasi teks, vektor diproses token demi token sehingga $N=1$), yang juga dikenal sebagai GEMV (General Matrix-Vector Multiplication).

2.2 Dasar Matematis Kuantisasi (Quantization)

Dalam inferensi di mana bandwidth akses memori menjadi hambatan, kuantisasi yang merepresentasikan parameter bobot dengan jumlah bit kecil sangatlah penting. Berikut adalah penjelasan prinsip dasar dari kuantisasi berbasis blok (seperti Q4_K atau Q4_0) yang banyak digunakan di llama.cpp.

Misalkan kita memiliki blok $w = [w_1, w_2, \dots, w_B]$ dengan panjang $B$ (biasanya 32 atau 64) yang merupakan bagian dari matriks bobot FP16 $W$. Blok ini diaproksimasikan menjadi bilangan bulat 4-bit $q_i \in [-8, 7]$ dan sebuah faktor penskalaan (scaling factor) tunggal $\Delta$ (FP16 atau FP32).

$$ w_i \approx \Delta \times q_i $$

Nilai $\Delta$ ditentukan berdasarkan nilai absolut maksimum di dalam blok tersebut:

$$ \Delta = \frac{\max_i |w_i|}{7} $$

Ketika menghitung perkalian titik (dot product) $y = w \cdot x$ menggunakan bobot yang telah dikuantisasi, jika vektor masukan $x$ juga dikuantisasi menjadi $x_i \approx \Delta_x \times q_{x, i}$, maka:

$$ y = \sum_{i=1}^{B} w_i x_i \approx \Delta \Delta_x \sum_{i=1}^{B} q_i q_{x, i} $$

Bagian $\sum q_i q_{x, i}$ ini sepenuhnya merupakan operasi bilangan bulat murni (pure integer arithmetic), yang dapat dikomputasi secara paralel dengan sangat cepat menggunakan instruksi SIMD. Inilah rahasia matematis di balik kecepatan llama.cpp yang luar biasa di CPU.

3. Arsitektur dan Alur Inferensi

Untuk memahami operasi internal llama.cpp, diagram Mermaid berikut menunjukkan arsitektur keseluruhan sistem dan aliran datanya.

graph TD A["Input Pengguna (String)"] --> B["Tokenizer llama.cpp"] B --> C["Token ID (array int32)"] C --> D["Buffer Konteks (KV Cache)"] D --> E["Grafik Komputasi ggml"] E --> F["Lapisan Transformer"] subgraph "Mesin ggml" F --> G["Self-Attention (RoPE)"] G --> H["Jaringan Feed Forward"] H --> F end F --> I["Logits (Ukuran Kosakata)"] I --> J["Sampler (Suhu, Top-K, Top-P)"] J --> K["ID Token Terpilih"] K --> L["Detokenizer llama.cpp"] L --> M["String Output"] K -. "Loop Auto-regressive" .-> D

Generasi teks adalah loop auto-regressive di mana setiap kali satu token dihasilkan, token tersebut ditambahkan ke KV Cache sebagai input berikutnya, lalu melewati grafik komputasi lagi.

4. Pengaturan Lingkungan dan Cara Build

Sebelum mengintegrasikan llama.cpp ke dalam proyek C++, mari kita mulai dengan mem-build kode sumbernya.

4.1 Kloning Repositori

1
2


git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

4.2 Build Menggunakan CMake

Ketika mengintegrasikannya ke aplikasi lain sebagai proyek C++, menggunakan CMake adalah pendekatan yang paling standar. Anda dapat mempercepat komputasi dengan mengaktifkan akselerator (backend) yang sesuai dengan platform masing-masing.

Hanya CPU (Build Dasar):

1
2
3


mkdir build && cd build
cmake ..
cmake --build . --config Release -j 8

Jika Menggunakan NVIDIA GPU (CUDA):

1
2
3


mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j 8

Jika Menggunakan Apple Silicon (Metal):

1
2
3


mkdir build && cd build
cmake .. -DGGML_METAL=ON
cmake --build . --config Release -j 8

Jika proses build berhasil, file eksekusi seperti llama-cli dan pustaka llama (serta pustaka ggml) yang akan di-link melalui API C++ yang dijelaskan nanti, akan dibuat di direktori build/bin/.

5. Pengenalan Kustomisasi dengan C++: Menggunakan API llama.cpp

Mulai dari sini, kita akan membahas topik utama yaitu mengendalikan llama.cpp dari kode C++. Untuk tidak sekadar menggunakan alat baris perintah (CLI), melainkan mengintegrasikan LLM ke dalam aplikasi Anda sendiri (seperti game engine, aplikasi desktop, sistem embedded, dll.), Anda perlu memanggil langsung API C++.

llama.cpp menyediakan antarmuka bahasa C terutama melalui header file bernama llama.h. Antarmuka ini juga digunakan ketika dipanggil dari C++.

5.1 Include dan Pengaturan Minimal yang Diperlukan

Jika Anda menggunakan llama.cpp di proyek Anda sendiri, masukkan pustaka berikut.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include "llama.h"
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

// Makro untuk error handling
#define LLAMA_ASSERT(x) \
 do { \
 if (!(x)) { \
 std::cerr << "Assertion failed: " << #x << std::endl; \
 std::terminate(); \
 } \
 } while (0)

5.2 Memuat Model dan Inisialisasi Konteks

Pertama, kita muat file model berformat .gguf dan menyiapkan konteks (ruang memori dan KV Cache) untuk inferensi.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


int main(int argc, char ** argv) {
 if (argc < 2) {
 std::cerr << "Usage: " << argv[0] << " <model.gguf>" << std::endl;
 return 1;
 }
 std::string model_path = argv[1];

 // 1. Inisialisasi backend (Pengaturan lingkungan seperti CPU/GPU)
 llama_backend_init();

 // 2. Mendapatkan pengaturan default parameter model
 llama_model_params model_params = llama_model_default_params();
 model_params.n_gpu_layers = 35; // Jumlah layer yang dialihkan ke GPU

 // 3. Memuat model
 llama_model * model = llama_load_model_from_file(model_path.c_str(), model_params);
 if (model == nullptr) {
 std::cerr << "Failed to load model" << std::endl;
 return 1;
 }

 // 4. Pengaturan parameter konteks
 llama_context_params ctx_params = llama_context_default_params();
 ctx_params.n_ctx = 2048; // Ukuran konteks maksimum (jumlah token)
 ctx_params.n_threads = 8; // Jumlah thread CPU yang digunakan untuk inferensi

 // 5. Membuat konteks
 llama_context * ctx = llama_new_context_with_model(model, ctx_params);
 if (ctx == nullptr) {
 std::cerr << "Failed to create context" << std::endl;
 llama_free_model(model);
 return 1;
 }

 std::cout << "Model and context loaded successfully!" << std::endl;
 // ... Pemrosesan selanjutnya

5.3 Tokenisasi Prompt (Tokenization)

LLM tidak secara langsung memahami teks, melainkan memprosesnya sebagai urutan ID integer (token). String input perlu dikonversi ke token.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


 std::string prompt = "Q: Apa ibu kota Jepang?\nA:";
 std::vector<llama_token> tokens_list;
 tokens_list.resize(prompt.length() + 4); // Ukuran buffer dengan ruang ekstra

 // Apakah akan menambahkan token khusus (seperti BOS: Begin of Sequence) di awal
 bool add_special = true;
 // Mengonversi string menjadi array ID token
 int n_tokens = llama_tokenize(
 model,
 prompt.c_str(),
 prompt.length(),
 tokens_list.data(),
 tokens_list.size(),
 add_special,
 false // parse_special
 );

 if (n_tokens < 0) {
 // Jika buffer tidak cukup, diperlukan proses untuk realokasi dan mencoba ulang (dihilangkan untuk penyederhanaan)
 std::cerr << "Failed to tokenize prompt" << std::endl;
 return 1;
 }
 tokens_list.resize(n_tokens);

5.4 Loop Inferensi dan Sampling

Kita membangun sebuah loop di mana token dimasukkan ke model untuk mendapatkan distribusi probabilitas (Logits) token berikutnya, lalu melakukan sampling dari sana untuk menentukan token selanjutnya.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


 // Jumlah token maksimum yang dihasilkan
 const int max_gen_tokens = 100;

 // Inisialisasi struktur untuk evaluasi batch
 llama_batch batch = llama_batch_init(512, 0, 1);

 // Menambahkan token prompt ke dalam batch
 for (size_t i = 0; i < tokens_list.size(); i++) {
 llama_batch_add(batch, tokens_list[i], i, { 0 }, false);
 }
 // Diatur agar hanya mengeluarkan logit (hasil prediksi) di token terakhir prompt
 batch.logits[batch.n_tokens - 1] = true;

 // Evaluasi awal (memasukkan prompt ke model)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "llama_decode() failed" << std::endl;
 return 1;
 }

 int n_cur = batch.n_tokens; // Panjang konteks saat ini
 int n_decode = 0;

 std::cout << "\nOutput: ";

 // Inisialisasi konteks sampler (Pengaturan Temperature, Top-K, Top-P, dll.)
 llama_sampler * smpl = llama_sampler_chain_init(llama_sampler_chain_default_params());
 llama_sampler_chain_add_top_k(smpl, 40);
 llama_sampler_chain_add_top_p(smpl, 0.9f, 1);
 llama_sampler_chain_add_temp(smpl, 0.7f);
 llama_sampler_chain_add_dist(smpl, 1234); // Nilai seed

 while (n_decode < max_gen_tokens) {
 // 1. Sampling: memprediksi token berikutnya berdasarkan konteks saat ini
 llama_token new_token_id = llama_sampler_sample(smpl, ctx, -1);

 // 2. Jika token adalah EOS (End of Sequence), hentikan loop
 if (llama_token_is_eog(model, new_token_id)) {
 break;
 }

 // 3. Dekode token menjadi string (teks) untuk ditampilkan
 char buf[128];
 int n_chars = llama_token_to_piece(model, new_token_id, buf, sizeof(buf), 0, false);
 if (n_chars > 0) {
 std::cout << std::string(buf, n_chars) << std::flush;
 }

 // 4. Persiapkan token baru yang dihasilkan sebagai batch berikutnya
 llama_batch_clear(batch);
 llama_batch_add(batch, new_token_id, n_cur, { 0 }, true);

 // 5. Evaluasi model (memperbarui KV Cache dan memprediksi selanjutnya)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "Failed to evaluate" << std::endl;
 break;
 }

 n_cur += 1;
 n_decode += 1;
 }

 std::cout << std::endl;

 // Bersihkan
 llama_sampler_free(smpl);
 llama_batch_free(batch);
 llama_free(ctx);
 llama_free_model(model);
 llama_backend_free();

 return 0;
}

Kode ini merupakan implementasi dari loop inferensi kustom yang menggunakan API dasar llama.cpp. Kode ini menggunakan struktur llama_batch untuk mengelola sekumpulan token, dan menggunakan llama_decode untuk menjalankan forward pass dari jaringan saraf.

6. Contoh Kustomisasi Lanjutan: Manipulasi Logit dan Kontrol Penalti dengan C++

Jika kita tidak hanya melakukan pembuatan teks sederhana, tetapi ingin memaksakan format output tertentu (seperti hanya JSON), atau mencegah dihasilkannya kata-kata terlarang tertentu, kita bisa secara langsung memanipulasi Logit dari sisi C++ sebelum sampling dilakukan.

Anda bisa mendapatkan array dari skor mentah (nilai sebelum dikonversi menjadi probabilitas) yang dihasilkan model tepat sebelum setiap token dikeluarkan.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Dapatkan array logit mentah tepat setelah inferensi, sebelum sampling dilakukan
float * logits = llama_get_logits_ith(ctx, batch.n_tokens - 1);
int n_vocab = llama_n_vocab(model);

// Daftar ID token terlarang (sebagai contoh 1234, 5678)
std::vector<llama_token> forbidden_tokens = { 1234, 5678 };

// Mengatur probabilitas kemunculan token terlarang menjadi 0 (Logit menjadi minus tak terhingga)
for (llama_token bad_tok : forbidden_tokens) {
 logits[bad_tok] = -INFINITY;
}

Dengan mengelola API C++ secara langsung, “intervensi berskala mikromilidetik pada setiap siklus inferensi” bisa dilakukan, sesuatu yang mungkin sulit dicapai atau memakan overhead yang terlalu besar jika dilakukan melalui LangChain atau Python.

7. Rahasia Penyetelan Kinerja (Performance Tuning)

Setelah implementasi di C++ selesai, berikut adalah beberapa poin untuk diperiksa guna meningkatkan kecepatan hingga batas maksimal untuk produksi yang sebenarnya.

Optimasi Pemrosesan Batch: Jika Anda memproses permintaan dari beberapa pengguna secara bersamaan, sertakan beberapa sequence dalam llama_batch dan panggil llama_decode sekaligus (Continuous Batching). Hal ini memungkinkan akses memori untuk dibagikan sehingga dapat meningkatkan throughput secara dramatis.
Mengaktifkan Flash Attention: Dengan menetapkan ctx_params.flash_attn = true; pada parameter konteks, komputasi Attention bisa dipercepat sembari mengurangi penggunaan memori. Ini merupakan pengaturan yang diwajibkan bila menangani konteks yang panjang (puluhan ribu token).
Dukungan NUMA: Di lingkungan server multi-socket, konfigurasi NUMA yang tepat sebelum memanggil llama_backend_init() dapat mengurangi latensi dari akses memori.

8. Kesimpulan

Pada artikel ini, kita telah membahas secara mendalam mulai dari latar belakang matematis llama.cpp, penjelasan arsitektur, hingga cara membangun mesin inferensi kustom menggunakan API C++.

Ekosistem Python sangat berguna untuk pembuatan prototype, namun untuk deployment di perangkat edge, integrasi ke dalam game, atau dalam lingkungan produksi yang menuntut pemrosesan secara real-time, pengontrolan langsung llama.cpp berbasis C/C++ menunjukkan kekuatan yang luar biasa.

Kami sangat menyarankan Anda untuk mencoba menulis kode C++ dengan tangan Anda sendiri dan merasakan serunya mengendalikan LLM secara bebas di lingkungan lokal.

Tautan Referensi

Repositori Resmi llama.cpp

ggml - Tensor Library

Attention Is All You Need (Vaswani et al., 2017)

【Terbaru 2026】Panduan Lengkap Menjalankan LLM Lokal di Lingkungan Windows

Fri, 11 Sep 2026 10:00:00 +0900

1. Pendahuluan: Mengapa LLM Lokal di Windows Sekarang?

Pada tahun 2026, evolusi AI Generatif dan Large Language Models (LLM) menunjukkan pergeseran paradigma besar dari layanan API raksasa di cloud ke “LLM lokal” yang berjalan di PC pribadi atau lingkungan on-premise. AI cloud seperti GPT-5 dari OpenAI dan Claude 3.5 dari Anthropic sangat kuat, namun tidak semua perusahaan atau individu dapat mengirimkan seluruh data mereka ke cloud. Dari perspektif privasi, keamanan, latensi, serta biaya jangka panjang dan berkelanjutan, permintaan untuk LLM lokal meningkat pesat seperti yang belum pernah terjadi sebelumnya.

Khususnya di lingkungan Windows, evolusi ekosistem LLM lokal sangat luar biasa. Hingga beberapa tahun yang lalu, menjadi rahasia umum bahwa “pengembangan dan eksekusi AI sama dengan Linux”, tetapi pada tahun 2026, Windows telah bertransformasi menjadi platform AI yang sangat kuat dan mudah digunakan.

Artikel ini memberikan panduan lengkap untuk membangun, mengoperasikan, dan mengoptimalkan LLM lokal di lingkungan Windows, berdasarkan tren teknologi terbaru tahun 2026. Mulai dari pengaturan sederhana menggunakan Ollama untuk pemula, optimasi ekstrem memanfaatkan llama.cpp untuk pengguna tingkat lanjut, hingga pemahaman mendalam tentang arsitektur dan pendekatan matematis perhitungan VRAM, serta fine-tuning lokal, kami akan menjelaskannya secara menyeluruh dengan volume yang melimpah.

1.1 Tren Teknologi Seputar LLM Lokal Tahun 2026

Tren utama yang membentuk ekosistem LLM lokal saat ini adalah sebagai berikut:

Adopsi Penuh Format GGUF: GGUF (GPT-Generated Unified Format), yang mengintegrasikan metadata dan tensor ke dalam satu file, telah sepenuhnya menjadi standar de facto. Ini memungkinkan eksekusi di lingkungan mana pun hanya dengan mengunduh satu file dari Hugging Face.
Demokratisasi Arsitektur MoE (Mixture of Experts): Banyak model MoE berskala kecil namun berkinerja tinggi telah dirilis. Dengan hanya mengaktifkan beberapa “ahli” selama inferensi, ini mencapai kinerja yang sebanding dengan model raksasa sambil menekan beban komputasi PC konsumen.
Abstraksi dan Optimasi Lanjutan dari Mesin Inferensi: Alat seperti Ollama, LM Studio, dan AnythingLLM telah disempurnakan, sehingga pengguna tidak perlu lagi peduli dengan dependensi kompleks seperti instalasi driver CUDA. Selain itu, dengan dukungan asli Windows untuk FlashAttention 3, kecepatan inferensi meningkat secara dramatis.
Pemanfaatan NPU dan Kemunculan PC Windows Copilot+: Bahkan pada laptop tanpa GPU, teknologi yang menggunakan NPU (Neural Processing Unit) bawaan untuk menjalankan LLM skala kecil (SLM: Small Language Models) dengan konsumsi daya rendah telah mencapai tahap praktis.

2. Persyaratan Perangkat Keras dan Persiapan OS

Untuk menjalankan LLM lokal pada kecepatan yang praktis (15-30 token atau lebih per detik), pemilihan perangkat keras adalah yang paling penting.

2.1 Konfigurasi Perangkat Keras yang Disarankan

Seiring dengan evolusi PC AI, spesifikasi yang dibutuhkan juga berubah.

OS: Windows 11 Pro (24H2 atau lebih baru). Diperlukan untuk memanfaatkan fungsionalitas penuh WSL2, manajemen memori tingkat lanjut, dan API terbaru dari DirectML.
CPU: Intel Core Ultra seri 200 ke atas, atau AMD Ryzen seri 9000 ke atas. Saat menggunakan inferensi CPU bersama-sama, komunikasi memori bandwidth tinggi sangat penting.
RAM: Minimal 32GB, disarankan 64GB atau lebih. Bandwidth memori utama (MB/s) menjadi bottleneck penentu selama inferensi CPU atau offloading. Memori berkecepatan tinggi DDR5-6000 atau lebih adalah ideal.
GPU: NVIDIA seri RTX 4000/5000. Dalam LLM lokal, yang paling penting bukanlah kinerja komputasi melainkan “kapasitas VRAM”.
- Entry level: RTX 4060 Ti (versi 16GB) - Kinerja biaya (cost-performance) terbaik. Sangat cocok untuk model kelas 8B-14B.
- Menengah (Mid-range): RTX 4070 Ti SUPER (16GB) / RTX 4080 SUPER (16GB)
- High-end: RTX 4090 (24GB) / RTX 5090 (32GB) - Diperlukan untuk menjalankan model terkuantisasi kelas 30B-70B.
Penyimpanan: SSD NVMe PCIe Gen4 atau Gen5. Mengurangi waktu pemuatan model puluhan GB secara dramatis.

2.2 Pengaturan WSL2 (Windows Subsystem for Linux 2)

Meskipun banyak alat GUI berjalan secara native di Windows, WSL2 sangat praktis untuk pengembangan menggunakan Python, kompilasi alat terbaru, dan fine-tuning LoRA yang akan dijelaskan nanti. Di lingkungan Windows 11 terbaru, hanya dengan menginstal driver NVIDIA di sisi host, GPU (CUDA) dapat digunakan secara transparan dari WSL2.

Buka PowerShell dengan hak administrator dan jalankan berikut ini:

1
2
3
4
5


# Instalasi WSL2 dan Ubuntu terbaru
wsl --install -d Ubuntu-24.04

# Pembaruan kernel
wsl --update

Setelah instalasi, jalankan nvidia-smi di terminal WSL2. Jika GPU terdeteksi secara normal, instalasi berhasil.

3. Arsitektur LLM Lokal dan Mekanisme Inferensi

Memahami struktur internal bagaimana model menghasilkan teks di lingkungan lokal sangat berguna untuk pemecahan masalah dan pengoptimalan.

Diagram Mermaid di bawah ini menunjukkan alur (pipeline) inferensi LLM lokal yang umum.

graph TD User["Input Pengguna (Prompt)"] --> Tokenizer["Tokenizer (Tokenizer)"] Tokenizer --> Embedding["Lapisan Penyematan (Embedding)"] subgraph "Transformer Block (x Layers)" Embedding --> Attn["Perhatian Diri (Self-Attention)"] Attn --> KVCache["Cache KV (Penyimpanan Key/Value)"] Attn --> FFN["Jaringan Feed-Forward (FFN)"] end FFN --> Logits["Perhitungan Logit (Logits)"] Logits --> Sampler["Sampler (Temperature, Top-K, Top-P)"] Sampler --> OutputToken["Token Output"] OutputToken --> |"Pembuatan Autoregresif"| Tokenizer OutputToken --> Decoder["Detokenizer (Detokenizer)"] Decoder --> FinalOutput["Teks Output Akhir"]

3.1 Dua Fase: Prefill dan Decode

Pembuatan teks LLM dibagi menjadi dua fase dengan karakteristik komputasi yang berbeda.

Fase Prefill (Pemrosesan Prompt): Ini adalah fase untuk memproses dan memahami seluruh prompt input sekaligus. Karena komputasi paralel memungkinkan, kapasitas komputasi GPU (FLOPS) berbanding lurus dengan kecepatan. Jika prompt panjang, fase ini bisa memakan waktu beberapa detik.
Fase Decode (Pembuatan Token): Fase ini memprediksi token demi token dan memasukkannya kembali sebagai input berikutnya (autoregresif). Karena komputasi paralel terbatas dalam fase ini, bandwidth VRAM GPU (Memory Bandwidth) menjadi bottleneck penentu.

4. Perhitungan Konsumsi VRAM dan Pemahaman Matematis Ukuran Model

Untuk menilai dengan tepat “model mana yang dapat berjalan di PC saya?”, Anda perlu memahami rumus perhitungan VRAM. Jika fallback ke memori sistem (RAM) terjadi karena kekurangan VRAM, kecepatan inferensi akan melambat 10 hingga 100 kali lipat.

4.1 VRAM Dasar Berdasarkan Ukuran Parameter

Ini adalah jumlah memori untuk memuat bobot (weights) model ke dalam VRAM. Dihitung menggunakan ukuran model $P$ (jumlah parameter, satuan: 1 Miliar = 1B) dan jumlah byte per parameter $B$.

$$ V_{base} = P \times B \quad \text{(GB)} $$

Misalnya, jika memuat model parameter 8B (8 miliar) dalam FP16 (titik mengambang presisi setengah, 16-bit = 2 byte):

$$ V_{base} = 8 \times 2 = 16 \text{ GB} $$

Dengan kata lain, meskipun GPU memiliki VRAM 16GB, batasnya sudah hampir tercapai hanya dengan memuat model.

4.2 Keajaiban Kuantisasi (Quantization)

Di sinilah “kuantisasi” muncul. Ini secara dramatis mengurangi ukuran model dengan menurunkan presisi parameter. Pada kuantisasi 4-bit yang paling umum (contoh: Q4_K_M), rata-rata adalah sekitar 0,55 byte per parameter.

$$ V_{base\_4bit} = 8 \times 0.55 = 4.4 \text{ GB} $$

Dengan demikian, jika Anda memiliki 16GB VRAM, Anda dapat menjalankan model 8B dengan kelonggaran yang cukup.

4.3 Perhitungan Cache KV (Versi Kompatibel GQA)

Selama inferensi, “Cache KV” untuk mempertahankan konteks masa lalu akan mengonsumsi VRAM. Pada model terbaru seperti Llama 3, GQA (Grouped Query Attention) diadopsi untuk menghemat memori.

Konsumsi Cache KV $V_{kv}$ (Gigabyte) direpresentasikan oleh rumus berikut.

$$ V_{kv} = 2 \times b \times s \times l \times \left( \frac{h_{kv}}{h_q} \right) \times h_q \times d \times B_{kv} \div 10^9 $$

Disederhanakan, ini dapat dihitung dengan mudah menggunakan jumlah head key dan value $h_{kv}$.

$$ V_{kv} = 2 \times b \times s \times l \times h_{kv} \times d \times B_{kv} \div 10^9 $$

Di mana:

$b$: Ukuran batch (biasanya 1 untuk penggunaan lokal pribadi)
$s$: Panjang sekuens (panjang konteks, contoh: 8192)
$l$: Jumlah lapisan (contoh: 32)
$h_{kv}$: Jumlah head KV (contoh: 8)
$d$: Jumlah dimensi per head (contoh: 128)
$B_{kv}$: Jumlah byte dari Cache KV (2 untuk FP16)

Contoh perhitungan (Llama 3 8B, konteks 8192, Cache FP16): $V_{kv} = 2 \times 1 \times 8192 \times 32 \times 8 \times 128 \times 2 \div 10^9 \approx 1.07 \text{ GB}$

Perhatikan bahwa semakin panjang panjang konteks $s$, VRAM yang dibutuhkan akan meningkat secara linier.

5. Praktik 1: Pengaturan Tercepat & Tersingkat Menggunakan Ollama

Setelah memahami teorinya, mari kita coba menjalankan LLM di lingkungan Windows secara nyata. Hingga tahun 2026, alat yang paling ramah pengguna adalah “Ollama”. Ia menyediakan CLI intuitif yang mirip Docker.

5.1 Instalasi dan Eksekusi

Unduh penginstal versi Windows dari Situs Resmi Ollama dan jalankan.
Buka PowerShell dan masukkan perintah berikut. Di sini, kita akan menggunakan llama3:8b yang mendukung bahasa Jepang.

1

ollama run llama3:8b

Pada percobaan pertama, model akan diunduh. Setelah selesai, Anda dapat langsung berinteraksi di terminal.

5.2 Pembuatan AI Kustom dengan Modelfile

Anda dapat dengan mudah membuat AI yang memiliki persona tertentu. Buat Modelfile di lokasi yang diinginkan.

1
2
3
4
5
6
7
8
9


FROM llama3:8b

SYSTEM """
Anda adalah insinyur perangkat lunak senior yang sangat hebat.
Untuk pertanyaan pengguna, selalu jawab secara logis dan ringkas, dengan menyertakan contoh kode.
"""

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

Bangun model kustom Anda sendiri dan jalankan dengan perintah berikut.

1
2


ollama create SeniorDev -f ./Modelfile
ollama run SeniorDev

5.3 Penggunaan dari Aplikasi Eksternal (AI Editor)

Ollama mengekspos endpoint API yang kompatibel dengan OpenAI di http://localhost:11434. Hanya dengan mengatur URL ke atas di pengaturan backend ekstensi VS Code seperti Cursor atau Continue.dev, dan menetapkan nama model ke SeniorDev dll, Anda mendapatkan asisten pengkodean lokal yang kuat secara gratis.

6. Praktik 2: Penyesuaian Kinerja Ekstrem dengan llama.cpp

Jika Anda ingin mencoba manajemen memori yang mendetail atau format terbaru (seperti kuantisasi EXL2 atau IQ) sesegera mungkin, operasikan langsung mesin intinya llama.cpp.

6.1 Langkah Build llama.cpp

Di lingkungan Windows, yang terbaik adalah membangun dari sumber menggunakan CUDA Toolkit dan CMake.

1
2
3
4
5
6
7
8


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build

# Konfigurasi dan kompilasi untuk dukungan CUDA
cmake .. -DLLAMA_CUBLAS=ON -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release -j 16

6.2 Peluncuran Lanjutan dalam Mode Server

Gunakan llama-server.exe yang telah dibangun untuk meng-host model.

1
2
3
4
5
6
7


.\bin\Release\llama-server.exe `
 --model "C:\models\Llama-3-8B-Instruct.Q4_K_M.gguf" `
 --ctx-size 8192 `
 --n-gpu-layers 99 `
 --threads 8 `
 --flash-attn `
 --port 8080

--n-gpu-layers 99: Membongkar (offload) semua lapisan yang memungkinkan ke VRAM GPU.
--flash-attn: Mengaktifkan FlashAttention 3, mencapai peningkatan kecepatan inferensi dan pengurangan konsumsi VRAM dari Cache KV.

7. GUI Frontend: LM Studio dan Membangun RAG Lokal

Jika Anda tidak nyaman dengan baris perintah, atau jika Anda ingin melakukan RAG (Retrieval-Augmented Generation) secara intuitif, gunakan GUI.

7.1 LM Studio

LM Studio adalah aplikasi brilian yang menggabungkan pencarian model, pengunduhan, pemeriksaan awal persyaratan sistem, dan bahkan UI obrolan menjadi satu. Cukup dengan menekan tombol “Local Server” di dalam aplikasi, API yang kompatibel dengan OpenAI akan dimulai.

7.2 Arsitektur RAG menggunakan AnythingLLM

Berikut adalah diagram arsitektur lingkungan RAG untuk membaca dokumen internal perusahaan atau catatan pribadi.

graph LR Document["Dokumen (PDF, MD)"] --> Chunking["Pembagian Potongan (Chunking)"] Chunking --> EmbedModel["Model Penyematan"] EmbedModel --> VectorDB["Database Vektor"] UserQuery["Pertanyaan Pengguna"] --> EmbedQuery["Penyematan Pertanyaan"] EmbedQuery --> VectorDB VectorDB --> |"Pencarian Kemiripan"| RetrievedDocs["Ekstraksi Dokumen Terkait"] UserQuery --> PromptBuilder["Pembuatan Prompt"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["LLM Lokal"] LocalLLM --> Answer["Jawaban Akhir"]

Dengan AnythingLLM versi desktop (Windows), Anda hanya perlu menentukan Ollama (LLM dan Embedding) dari layar pengaturan, dan mengaturnya untuk menggunakan VectorDB lokal (LanceDB), dan arsitektur ini selesai dalam beberapa menit. Lahirlah AI privat yang tidak mengirimkan data apa pun ke luar.

8. Fine-tuning (LoRA) di Windows WSL2

Jika Anda tidak hanya ingin menjalankannya secara lokal, tetapi juga ingin membuat model Anda lebih pintar dengan data Anda sendiri, fine-tuning menggunakan LoRA (Low-Rank Adaptation) dimungkinkan. Hingga tahun 2026, menggunakan pustaka bernama “Unsloth”, pelatihan model 8B dapat diselesaikan dalam beberapa jam bahkan dengan VRAM 16GB di lingkungan Windows WSL2.

Jalankan berikut ini di dalam Ubuntu WSL2 untuk mengatur lingkungan.

1
2
3
4


conda create --name unsloth_env python=3.11
conda activate unsloth_env
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

Unsloth mengoptimalkan kernel CUDA hingga batasnya, mencapai kecepatan pelatihan sekitar 2 kali lipat dan mengurangi konsumsi VRAM hingga separuhnya dibandingkan dengan pustaka Hugging Face standar. Hanya dengan meluncurkan Jupyter Notebook dan memuat kumpulan data (format JSONL), Anda dapat melakukan pelatihan beberapa epoch bahkan pada RTX 4060 Ti dll dengan VRAM 12GB hingga 16GB.

9. Pemecahan Masalah Kinerja

Ini adalah masalah umum dan solusinya.

1. Kecepatan inferensi sangat lambat (1-2 token/s)

Penyebab: Model tidak muat sepenuhnya di VRAM dan sedang dibongkar (offload) ke memori sistem (RAM). Solusi: Periksa “Memori GPU Khusus” di Task Manager. Jika mencapai batas, kurangi ukuran konteks (-c) atau gunakan model kuantisasi dengan bit yang lebih rendah (seperti Q4_K_M).

2. Kesalahan “CUDA out of memory”

Penyebab: VRAM telah habis sepenuhnya. Ini terutama terjadi ketika percakapan diperpanjang dan Cache KV membengkak. Solusi: Secara sengaja batasi nilai num_ctx untuk Ollama atau -c untuk llama.cpp menjadi lebih kecil.

3. Pembuatan teks bahasa Jepang/Indonesia aneh

Penyebab: Ketidaksesuaian template prompt, atau model yang tidak didukung. Solusi: Gunakan model yang menyertakan Instruct dalam namanya, dan pastikan template yang benar yang ditentukan oleh pembuat model, seperti format ChatML atau Llama3, dipilih di sisi alat.

10. Kesimpulan dan Prospek Masa Depan

Pada tahun 2026, membangun LLM lokal di lingkungan Windows tidak lagi menjadi hak istimewa eksklusif segelintir insinyur. Melalui standar de facto format GGUF, munculnya ekosistem yang disempurnakan seperti Ollama dan LM Studio, serta pengoptimalan perangkat keras termasuk FlashAttention, siapa pun kini dapat dengan mudah memperoleh lingkungan AI tingkat perusahaan (enterprise).

Silakan manfaatkan poin-poin yang dijelaskan dalam artikel ini:

Gunakan perhitungan matematis VRAM untuk secara logis memilih ukuran model dan tingkat kuantisasi yang paling sesuai dengan spesifikasi PC Anda.
Gunakan Ollama untuk membangun lingkungan tercepat dan meningkatkan produktivitas secara dramatis dengan menghubungkannya ke editor AI.
Gunakan kontrol parameter lanjutan dari llama.cpp untuk memaksimalkan kinerja batas perangkat keras Anda.
Gunakan AnythingLLM untuk membangun sistem RAG lokal yang aman yang menangani data rahasia.
Manfaatkan Unsloth (WSL2) untuk melatih AI kustom yang memiliki pengetahuan khusus Anda sendiri.

“Demokratisasi” AI tidak lagi sekadar buzzword, tetapi sistem nyata yang berjalan di desktop Windows Anda. Bebaskan diri Anda dari biaya penggunaan API cloud dan risiko kebocoran informasi, serta melangkahlah sekarang ke dunia AI privat yang bebas dan kuat.