Menjalankan Gemini di Laptop Pribadi secara lokal [NO INTERNET]

Semua orang pasti pernah pakai AI sekarang, entah itu ChatGPT yang pertama kali mempopulerkan tren generative AI, lalu kemudian ada Gemini AI, DeepSeek, lalu ada juga AI Agent yang khusus dipakai buat melakukan tugas spesifik, misal seperti mencari paper untuk research menggunakan Perplexity, BlackBox Screenshot to Webapp yang mengubah Screenshot mockup aplikasi menjadi dalam bentuk kode program. Tapi pernah kepikiran ga si, kalau kita sebenernya bisa running LLM (Large Language Model) kita sendiri di laptop kita?

Open Weight Model

Tentu saja kalau kita traning model LLM kita sendiri di laptop bakal butuh resource yang ga main-main. maka dari itu, kita pakai model yang sudah di train oleh perusahaan-perusahaan baik hati yang mau membagikan "weight" atau model yang sudah di train oleh mereka untuk kita run di mesin lokal kita sendiri.

Ada banyak jenis Open Weight Model di luar sana, seperti LLama, Gemma, GPT OSS, dengan berbagai jenis ukuran parameter, mulai dari 1.5 Billion parameter, sampai salah satu yang paling berat yaitu dari Deepseek, dengan ukuran sampai 671 Billion parameter, model terpintar yang performanya katanya bisa mengalahkan GPT model terbaru.

Yang kita pakai

Nah, karena kita sadar diri, jadi kita coba run yang ringan-ringan saja. Disini kita akan coba running model Gemma-3 1B secara lokal di komputer kita. Model ini bisa kalian akses di huggingface menggunakan link berikut:

https://huggingface.co/google/gemma-3-1b-it

Tapi sebelum itu, pastikan kalian sudah punya akses ke repository Google's Gemma Model Family seperti berikut:

Jika belum, teman-teman perlu login dan kemudian mengisi form pengajuan akses yang kemudian akan di review oleh maintaner repo Gemma (tenang aja, pasti di acc kok)

Prasyarat

Untuk menjalankan model ini di lokal, teman-teman perlu beberapa hal seperti berikut:

Python versi terbaru: python 3.13.7
PIP versi terbaru: pip 25.2
Huggingface CLI, bisa didownload lewat pip dengan perintah: pip install -U "huggingface_hub[cli]"
llama.cpp (compile manual dari repo github resmi: https://github.com/ggml-org/llama.cpp)
OS: bebas, tapi disini aku pakai Ubuntu WSL di windows, kalau teman-teman sudah ada wsl atau linux, lebih disarankan pakai itu karena bakal lebih stabil.

Menyiapkan model

Autentikasi terlebih dahulu huggingface cli menggunakan token yang kalian dapatkan dari menu Access Tokens di pengaturan akun huggingface kalian:

Gunakan perintah berikut untuk melakukan autentikasi di command line:

hf auth login

Akan muncul seperti berikut

Kemudian paste token yang sudah kalian buat disitu, tenang aja emang sengaja ga terlihat.

Setelah sudah berhasil ter autentikasi, kalian bisa langsung saja download repo Gemma 3 (pastikan sudah memiliki akses), kemudian jalankan perintah berikut di terminal/command prompt:

hf download google/gemma-3-1b-it

Kalian bisa jalanin perintah itu di folder tempat kalian pengen simpan model nya ya, disini aku install di ~/code/pythons.

Maka dia akan mengunduh model tersebut secara lokal di laptop kita:

Jika sudah terdownload, maka akan muncul file-file berikut:

Pada tahap ini kita sudah berhasil mengunduh model Gemma 3 real ke laptop kita sendiri secara lokal. Step selanjutnya adalah menjalankannya!

Menyiapkan llama.cpp

Karena laptop ku gapunya GPU, jadi aku mau memaksimalkan kemampuan CPU yang aku punya, maka dari itu aku perlu memasang llama.cpp yang berfungsi sebagai backend yang bisa menggunakan resource CPU secara optimal sehingga dia bisa menjalankan model kita dengan cukup lancar.

Tapi setelah aku coba, model Gemma 1b ini masih terlalu berat di laptop ku (sad), jadi satu hal yang perlu aku lakukan adalah meng-quantize model ini (a.k.a mengkompres modelnya) biar bisa jalan dengan lumayan cepat di laptop lokalku.

Nah untuk mencompile llama cpp nya sendiri, kita perlu clone repository nya seperti yang sudah aku jelasin sebelumnya di prasyarat

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

Setelah itu dia akan mengunduh repo llama.cpp secara lokal di laptop kita, disini aku download dia di folder yang sama kaya folder tempat aku download si gemma nya (di ~/code/pythons/):

Setelah sudah berhasil di download, kita bisa build object nya menggunakan perintah berikut:

cmake -B build

Output dari punya ku lebih pendek karena emang aku udah pernah build llama.cpp ini, mungkin punya kalian akan lebih panjang/detail karena build ulang dari awal.

Setelah itu kita link objeknya menjadi bentuk executable binary yang bisa kita run, berikut caranya:

cmake --build build --config Release

Kalau sudah, kita bisa tes apakah buildnya jadi atau tidak:

./build/bin/llama-cli --version

Kalau outputnya seperti ini:

Berarti aman.

Kalau misal punya kalian OS nya beda gapapa, disini aku pakai Ubuntu makannya dia ada tulisan "Ubuntu 11.4.0"

Menjalankan Model

Jadi kita sudah punya alat buat jalanin model kita, tapi belum selesai, model yang kita download dari huggingface itu masih formatnya hf, jadi spesifik dari huggingface itu sendiri, nah kalau kita mau jalanin model itu pakai llama.cpp, kita harus ubah dulu jadi format .gguf, untung saja dari llama.cpp udah menyediakan file nya (script python):

Nah karena ini python, kita perlu install requirement nya dulu dari folder requirements/

Kita cuma perlu file convert_hf_to_gguf.py, jadi kita cukup install requirements untuk file itu aja:

pip install -r requirements/requirements-convert_hf_to_gguf.txt

Maka dia akan install requirementnya:

Tunggu sampai selesai.

Convert model Huggingface ke .gguf

Setelah selesai, kita bisa convert folder repo hasil hf download kita tadi, ke format gguf, caranya begini

Masuk dulu ke folder repo gemma tadi:

Setelah itu, kita jalankan script nya dari folder llama.cpp:

python ../llama.cpp/convert_hf_to_gguf.py ./ --outfile gemma-3-1b-it.gguf

Maka akan muncul seperti ini:

Tunggu sampai konversi selesai seperti berikut:

Kalau sudah, artinya konversi sudah berhasil, yay!

Running model

Selamat! akhirnya kita sampai di penghujung tutorial ini, dan bisa menjalankan gemini kita sendiri di lokal, caranya kita tinggal run aja binary llama-cli dari folder build/bin nya llama.cpp, tambahkan parameter -m diikuti dengan nama file .gguf yang mau kita jalankan, contoh:

../llama.cpp/build/bin/llama-cli -m gemma-3-1b-it.gguf

Kita juga bisa atur parameter modelnya seperti context size, temperature, dan lain sebagainya:

../llama.cpp/build/bin/llama-cli -m ./gemma-3-1b-it.gguf -c 2048 --temp 0.3 --top-p 0.9 --repeat-penalty 1.1

Keterangan command:

-m ./gemma-3-1b-it.gguf

Model yang dipakai untuk inferensi.
Ini file .gguf dari model Gemma.

-c 2048

Jumlah context window tokens. Menentukan seberapa panjang “ingatan jangka pendek” model saat ngobrol.
Semakin besar, semakin banyak konteks yang bisa dipahami, tapi butuh lebih banyak RAM dan waktu inferensi.

--temp 0.3

Temperature (suhu kreativitas). Mengatur tingkat randomness atau variasi jawaban.
0.0 = kaku & deterministik (fokus ke jawaban paling pasti)
1.0 = kreatif & bebas (kadang ngawur)
0.3 ini pas buat hasil yang stabil dan fokus (kayak mode kerja serius).

--top-p 0.9

Nucleus sampling.
Model akan memilih kata berikutnya hanya dari 90% probabilitas teratas.
Menyaring kata yang terlalu random tanpa bikin hasil monoton.

--repeat-penalty 1.1

Hukuman untuk pengulangan kata/frasa.
Supaya model nggak ngulang-ngulang kayak kaset rusak (“iya iya iya iya…”).
Nilai > 1 bikin model lebih variatif,
nilai < 1 malah bikin dia suka nge-loop.

Untuk keluar dari sesi interaktif bisa tekan CTRL+D atau CTRL+C:

Dan akan keluar summary sesi nya yang isinya performa modelnya.

Quantization (opsional)

Kalau kalian merasa percaya diri, bisa coba run langsung aja model gguf itu pakai command llama-cli:

../llama.cpp/build/bin/llama-cli -m gemma-3-1b-it.gguf

Tunggu modelnya loading, setelah muncul seperti ini (Running in interactive mode), kalian bisa langsung chat:

Tapi di laptopku ini relatif lelet, kalau aku liat dia cuma menghasilkan 9.31 token per detik:

Makannya aku mau quantize modelnya jadi Q8_0.

Tapi kalian mungkin bingung, maksudnya quantization itu apa? jadi gini

Quantization adalah teknik mengecilkan ukuran model dengan mengubah angka-angka bobotnya dari presisi tinggi (float32) jadi presisi lebih rendah (int8, int4, dst.)

Nah, aku mau pakai quantization paling tinggi yaitu Q8_0, performanya mendekati model asli tapi udah dikurangin sedikit juga presisi perhitugannnya, jadi sekitar 8-bit float, dimana aslinya dia pakai 32 bit float. Dibawah itu aku notice model nya jadi sedikit "bodoh" kalau jawab hehe.

Caranya adalah:

../llama.cpp/build/bin/llama-quantize gemma-3-1b-it.gguf gemma-3-1b-it.Q8_0.gguf Q8_0

Maka akan keluar:

Kalau udah muncul seperti ini berarti sudah sukses:

Lumayan itu, terkompress dari 2GB ke 1GB an saja.

Untuk runningnya sama aja, tinggal pakai model yang sudah di quantize:

../llama.cpp/build/bin/llama-cli -m ./gemma-3-1b-it.Q8_0.gguf -c 2048 --temp 0.3 --top-p 0.9

--repeat-penalty 1.1

Hasilnya sama saja, bisa chat dengan lancar, cuma mungkin kali ini ada perbedaan jadi terasa lebih cepat waktu si model merespon pertanyaan kita, dan yap benar saja kalau kita lihat di statistik response model:

Kalau masih terasa berat, bisa dicoba opsi quantization lainnya yang memotong lebih banyak presisi dan menghasilkan model yang lebih ringan. Berikut opsi quantization yang bisa dipakai:

F16 / Q8_0. 16-bit / 8-bit float: Hampir tanpa kehilangan kualitas
Q6_K. 6-bit: Kompromi seimbang antara kecepatan & akurasi
Q5_K_M / Q5_K_S. 5-bit: Lebih kecil, masih akurat
Q4_K_M / Q4_K_S. 4-bit: Ukuran jauh lebih kecil, agak halu dikit
Q3_K_S / Q2_K. 3-bit / 2-bit: Super kecil, tapi banyak kehilangan akurasi

Begitu saja untuk artikel kali ini teman-teman, selamat mencoba sendiri dan bereksperimen sesuka hati hehe, sampai jumpa di postingan IHY Programming selanjutnya!

Kalau ada tanggapan atau pertanyaan boleh banget komen dibawah teman-teman!

Cari Blog Ini

IHY Programming