Berapa banyak RAM yang saya butuhkan untuk menjalankan Gemma 4 secara lokal?

Gemma 4 E2B dan E4B berjalan hanya dengan 5GB RAM dengan 4-bit quantization — laptop modern mana pun memenuhi syarat. Model 26B MoE membutuhkan sekitar 18GB RAM (muat dalam 24GB VRAM milik RTX 4090). Model 31B Dense membutuhkan sekitar 20GB RAM. Untuk eksekusi CPU-only, tambahkan RAM 20-30% lebih banyak dari ukuran bobot model.

Model Gemma 4 mana yang harus saya pilih untuk penggunaan lokal?

Untuk laptop tanpa GPU khusus: E2B (tercepat, teringan). Untuk laptop dengan GPU atau desktop: E4B (kualitas lebih baik, tetap ringan). Untuk desktop dengan RTX 4090 atau setara: 26B MoE (rasio kualitas-ke-komputasi terbaik). Untuk workstation dengan 24GB+ VRAM: 31B Dense (kualitas tertinggi). 26B MoE adalah pilihan yang paling pas (sweet spot) bagi sebagian besar pengembang.

Apakah Gemma 4 gratis untuk digunakan secara lokal?

Ya. Gemma 4 dirilis di bawah Apache 2.0, yang mengizinkan penggunaan tanpa batas termasuk aplikasi komersial. Ollama juga gratis dan open source. Satu-satunya biaya adalah hardware Anda. Tidak ada biaya API, tidak ada batas penggunaan, dan tidak ada batasan lisensi.

Seberapa cepat Gemma 4 secara lokal dibandingkan dengan cloud API?

Pada RTX 4090, Gemma 4 E4B menghasilkan 80-120 tokens per second. 26B MoE menghasilkan 30-50 tokens/sec. 31B Dense menghasilkan 20-35 tokens/sec. Cloud API seperti Google AI Studio mungkin lebih cepat untuk model terbesar tetapi menambah latensi jaringan sebesar 100-500ms per permintaan. Untuk penggunaan interaktif, local inference pada model yang lebih kecil terasa instan.

Bisakah saya menggunakan Gemma 4 secara lokal sebagai API untuk aplikasi saya?

Ya. Ollama menyediakan REST API lokal pada port 11434 yang kompatibel dengan format OpenAI API. Aplikasi, framework, atau alat apa pun yang mendukung OpenAI API dapat terhubung ke Gemma 4 lokal dengan mengarahkan base URL ke http://localhost:11434/v1. Ini mencakup Python, Node.js, dan sebagian besar AI frameworks.

Apakah Gemma 4 mendukung akselerasi GPU dengan Ollama?

Ya. Ollama secara otomatis mendeteksi dan menggunakan NVIDIA GPUs (CUDA), Apple Silicon (Metal), dan AMD GPUs (ROCm). Tidak diperlukan konfigurasi tambahan — jika GPU Anda memiliki VRAM yang cukup untuk menampung model, Ollama akan menggunakannya secara otomatis. NVIDIA juga telah merilis versi Gemma 4 yang teroptimasi RTX (RTX-optimized) untuk peningkatan performa tambahan.

Key Takeaway

Menjalankan Gemma 4 secara lokal memakan waktu kurang dari 5 menit dengan Ollama: pasang Ollama, jalankan satu perintah, dan Anda memiliki model AI yang sepenuhnya mampu berjalan di hardware Anda sendiri dengan biaya API nol, tidak ada data yang meninggalkan mesin Anda, dan nol batasan penggunaan di bawah Apache 2.0. Model E2B dapat berjalan di laptop apa pun. Model 26B MoE muat dalam satu RTX 4090 dan memberikan kualitas yang menyaingi model dengan jumlah parameter aktif 10x lipat darinya.

Menjalankan Gemma 4 Secara Lokal: Panduan Lengkap

Mengapa Menjalankan Gemma 4 Secara Lokal?

Sebelum masuk ke pengaturan, berikut adalah alasan mengapa inferensi lokal menjadi penting di 2026:

Privasi — Data Anda tidak pernah meninggalkan mesin Anda. Tidak ada prompt yang dikirim ke server eksternal. Sangat penting untuk kode proprietary, dokumen hukum, data medis, atau informasi sensitif apa pun.
Biaya — Nol biaya per-token setelah investasi hardware satu kali. Pengguna berat menghemat ratusan dolar per bulan dibandingkan dengan harga API.
Latensi — Tidak ada perjalanan pulang-pergi jaringan. Model E2B dan E4B merespons dalam hitungan milidetik pada hardware modern.
Keandalan — Tidak ada batasan rate limit API, tidak ada pemadaman layanan, tidak ada perubahan kebijakan penyedia. Model Anda selalu tersedia.
Kustomisasi — Lakukan fine-tune, quantize, dan modifikasi model secara bebas di bawah Apache 2.0.
Akses offline — Bekerja tanpa koneksi internet setelah model diunduh.

Gemma 4 sangat cocok untuk penerapan lokal karena Google merancang model yang lebih kecil secara khusus untuk penggunaan edge dan pada perangkat. Model E2B dan E4B bukanlah sekadar tambahan — mereka adalah model kelas utama yang dioptimalkan untuk keterbatasan hardware lokal.

Prasyarat

Persyaratan Hardware berdasarkan Model

Model	Minimum RAM	Recommended VRAM	CPU-Only Viable?	Disk Space
E2B (4-bit)	5 GB	4 GB	Yes	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Yes	~2.8 GB
E4B (FP16)	9 GB	9 GB	Slow	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Very slow	~15 GB
26B MoE (FP16)	52 GB	48 GB	No	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Very slow	~18 GB
31B Dense (FP16)	62 GB	48 GB+	No	~62 GB

Key takeaway: Jika Anda memiliki laptop yang dibuat setelah 2022, Anda dapat menjalankan E2B atau E4B. Jika Anda memiliki RTX 4090 (24GB VRAM) atau Apple M-series Mac dengan 32GB+ RAM, Anda dapat menjalankan 26B MoE atau 31B Dense pada kuantisasi 4-bit.

Persyaratan Perangkat Lunak

Operating system: macOS, Linux, atau Windows
Ollama: Versi 0.6+ (unduh dari ollama.com)
GPU drivers (opsional): NVIDIA CUDA 12+ untuk NVIDIA GPUs, tidak perlu driver tambahan untuk Apple Silicon

Langkah 1: Pasang Ollama

macOS

Unduh dari ollama.com/download atau gunakan Homebrew:

brew install ollama

Linux

Skrip instalasi satu baris:

curl -fsSL https://ollama.com/install.sh | sh

Windows

Unduh installer dari ollama.com/download dan jalankan. Ollama berjalan sebagai layanan latar belakang di Windows.

Verifikasi Instalasi

ollama --version

Anda seharusnya melihat ollama version 0.6.x atau lebih tinggi. Jika Anda melihat nomor versi, Ollama telah terpasang dengan benar.

Source: Ollama installation guide

Langkah 2: Ambil Model Gemma 4

Pilih model yang sesuai dengan hardware Anda:

Untuk Laptop dan Beban Kerja Ringan

# Model terkecil — berjalan di laptop modern mana pun (5GB RAM)
ollama pull gemma4:e2b

# Model kecil dengan kemampuan lebih luas (5-9GB RAM)
ollama pull gemma4:e4b

Untuk Desktop dengan GPU Dedikasi

# Efisiensi terbaik — kualitas unggulan pada 3.8B active params (18GB RAM)
ollama pull gemma4:26b-moe

# Kualitas tertinggi — parameter 31B penuh (20GB RAM)
ollama pull gemma4:31b

Menentukan Kuantisasi

Secara default, Ollama mengambil kuantisasi yang direkomendasikan untuk setiap model (biasanya Q4_K_M untuk keseimbangan kualitas-ke-ukuran yang baik). Anda dapat menentukan kuantisasi yang berbeda:

# Kualitas lebih tinggi, ukuran lebih besar
ollama pull gemma4:31b-q5_K_M

# Ukuran lebih kecil, kualitas sedikit lebih rendah
ollama pull gemma4:31b-q3_K_M

# Presisi penuh (membutuhkan lebih banyak RAM)
ollama pull gemma4:31b-fp16

Pengunduhan akan memakan waktu beberapa menit tergantung pada koneksi internet Anda. Ukuran model berkisar dari ~1.5GB (E2B 4-bit) hingga ~62GB (31B FP16).

Langkah 3: Jalankan Gemma 4

Chat Interaktif

ollama run gemma4:e4b

Ini akan membuka sesi chat interaktif. Ketik prompt Anda dan tekan Enter:

>>> What are the key differences between REST and GraphQL APIs?

Model akan merespons langsung di terminal Anda. Ketik /bye untuk keluar.

Prompt Tunggal (Non-Interaktif)

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

Dengan Mode Berpikir (Thinking Mode)

Gemma 4 mendukung mode berpikir yang dapat dikonfigurasi untuk tugas-tugas kompleks. Aktifkan dengan menambahkan system prompt:

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

Untuk tugas matematika, logika, dan analisis kompleks, mode berpikir secara signifikan meningkatkan kualitas jawaban. Model akan menghasilkan 4,000+ tokens penalaran internal sebelum memberikan respons akhirnya.

Langkah 4: Gunakan API Lokal

Ollama mengekspos REST API pada localhost:11434 yang kompatibel dengan format OpenAI API. Ini berarti alat atau library apa pun yang mendukung API OpenAI dapat terhubung ke Gemma 4 lokal Anda dengan perubahan URL sederhana.

Uji API dengan curl

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

Endpoint Kompatibel OpenAI

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

Source: Ollama API documentation

Langkah 5: Integrasikan dengan Aplikasi Anda

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# Penggunaan
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

Python dengan OpenAI SDK

from openai import OpenAI

# Arahkan ke Ollama lokal alih-alih OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama tidak memerlukan API key asli
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Menggunakan dengan LangChain

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

Menggunakan dengan LlamaIndex

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

Opsi Kuantisasi Dijelaskan

Kuantisasi mengurangi ukuran model dan penggunaan memori dengan menggunakan angka presisi lebih rendah untuk merepresentasikan bobot model. Tradeoff-nya adalah antara kualitas dan penggunaan sumber daya:

Kuantisasi	Bit per Bobot	Dampak Kualitas	Penghematan Memori	Terbaik Untuk
FP16	16 bits	Tidak ada (kualitas penuh)	Baseline	Server dengan VRAM melimpah
Q8_0	8 bits	Sangat kecil	~50%	Inferensi lokal kualitas tinggi
Q6_K	6 bits	Sangat minor	~62%	Penggunaan lokal fokus kualitas
Q5_K_M	5 bits	Minor	~69%	Keseimbangan yang baik
Q4_K_M	4 bits	Kecil	~75%	Default yang direkomendasikan
Q3_K_M	3 bits	Moderat	~81%	Hardware terbatas
Q2_K	2 bits	Signifikan	~87%	Batasan ekstrim

Q4_K_M adalah titik keseimbangan terbaik bagi sebagian besar pengguna. Perbedaan kualitas dari FP16 cukup kecil sehingga sebagian besar tugas menghasilkan hasil yang tidak dapat dibedakan, sementara penghematan memori sebesar 75% membuat perbedaan antara "membutuhkan server" dan "berjalan di laptop saya."

Memilih Kuantisasi yang Tepat

Untuk Gemma 4 E2B/E4B: Gunakan default (Q4_K_M). Model-model ini sudah cukup kecil sehingga kuantisasi yang lebih tinggi tidak mengubah pengalaman pengguna secara signifikan.

Untuk Gemma 4 26B MoE: Q4_K_M muat dalam 18GB RAM, yang berada dalam kapasitas 24GB VRAM RTX 4090 dengan ruang untuk KV cache. Jika Anda memiliki 48GB+ VRAM (A6000, dual GPUs), pertimbangkan Q8_0 untuk kualitas yang sedikit lebih baik.

For Gemma 4 31B Dense: Q4_K_M pada 20GB muat dalam RTX 4090 dengan margin yang ketat. Q5_K_M menghasilkan hasil yang sedikit lebih baik tetapi membutuhkan ~24GB, menghabiskan semua VRAM yang tersedia. Jika Anda memiliki 32GB+ VRAM (RTX 5090, A6000), Q6_K atau Q8_0 layak untuk ditingkatkan.

Pengoptimalan Performa

GPU Offloading

Ollama secara otomatis memindahkan layer model ke GPU saat VRAM tersedia. Jika hanya sebagian dari model yang muat di VRAM, Ollama membaginya antara GPU dan CPU. Anda dapat mengontrol ini:

# Paksa semua layer ke GPU (gagal jika VRAM tidak cukup)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Paksa hanya CPU (berguna untuk pengujian)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Konfigurasi Context Window

Secara default, Ollama menggunakan context window sebesar 2048 tokens untuk efisiensi. Untuk memanfaatkan kemampuan konteks penuh Gemma 4:

# Atur context window ke 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Atur context window ke 128K tokens (membutuhkan lebih banyak RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Penting: Context window yang lebih besar mengonsumsi lebih banyak RAM untuk KV cache. Context window 128K pada model 31B mungkin memerlukan tambahan 8-16GB RAM di luar bobot model. Mulailah dengan 32K dan tingkatkan hanya jika kasus penggunaan Anda memerlukannya.

Permintaan Konkuren

Ollama mendukung melayani beberapa permintaan secara bersamaan:

# Izinkan hingga 4 permintaan konkuren
OLLAMA_NUM_PARALLEL=4 ollama serve

Setiap permintaan konkuren menambah overhead memori untuk KV cache-nya. Pada GPU 24GB yang menjalankan 26B MoE pada Q4_K_M (~18GB), Anda memiliki ruang sekitar 6GB — cukup untuk 2-3 permintaan konkuren dengan konteks pendek.

Pengaturan Keep-Alive

Secara default, Ollama menjaga model tetap dimuat di memori selama 5 menit setelah permintaan terakhir. Sesuaikan ini untuk kasus penggunaan Anda:

# Jaga model tetap dimuat selama 1 jam
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Jaga model tetap dimuat selamanya
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Hapus dari memori segera setelah setiap permintaan (menghemat memori)
OLLAMA_KEEP_ALIVE=0 ollama serve

Optimalisasi NVIDIA RTX

NVIDIA telah merilis build Gemma 4 yang dioptimalkan untuk RTX GPUs. Optimalisasi ini meliputi:

Custom CUDA kernels untuk mekanisme attention Gemma 4
TensorRT-LLM integration untuk inferensi lebih cepat
Flash Attention dukungan untuk pengurangan penggunaan memori selama inferensi konteks panjang
Optimized KV cache management untuk throughput yang lebih baik

Memasang Gemma 4 yang Dioptimalkan NVIDIA

Jika Anda memiliki GPU seri RTX 4000 atau 5000:

# Periksa GPU Anda
nvidia-smi

# Ambil versi yang dioptimalkan NVIDIA (jika tersedia di Ollama)
ollama pull gemma4:31b-nvidia

Sebagai alternatif, gunakan NVIDIA AI Workbench atau TensorRT-LLM secara langsung untuk performa maksimum. Versi yang dioptimalkan NVIDIA dapat memberikan inferensi 30-50% lebih cepat pada RTX GPUs dibandingkan dengan build Ollama standar.

Benchmark Performa Dunia Nyata

Diukur pada konfigurasi hardware umum:

Tokens per Second (Kecepatan Generasi)

Model	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	CPU Only (32GB)
E2B (Q4)	~150 tok/s	~120 tok/s	~100 tok/s	~30 tok/s
E4B (Q4)	~100 tok/s	~80 tok/s	~70 tok/s	~15 tok/s
26B MoE (Q4)	~40 tok/s	~30 tok/s	~25 tok/s	~3 tok/s
31B Dense (Q4)	~30 tok/s	~20 tok/s	~20 tok/s	~2 tok/s

Konteks: Kecepatan membaca manusia kira-kira 4-5 tokens per detik. Model apa pun yang menghasilkan di atas 10 tok/s terasa "instan" untuk penggunaan interaktif. Model E2B dan E4B cukup cepat untuk real-time streaming di hampir semua hardware.

Time to First Token (Latensi)

Model	RTX 4090	M3 Max	CPU Only
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

Untuk aplikasi interaktif, waktu untuk token pertama lebih penting daripada kecepatan generasi. Model E2B dan E4B mulai menghasilkan hampir secara instan bahkan pada CPU, membuatnya ideal untuk antarmuka chat real-time.

Kasus Penggunaan Umum

Asisten Pemrograman Lokal

Gunakan Gemma 4 sebagai asisten pemrograman pribadi yang tidak pernah mengirimkan kode Anda ke server eksternal:

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

Pasangkan ini dengan ekstensi VS Code seperti Continue atau Twinny yang mendukung Ollama sebagai backend.

Analisis Dokumen

Proses dokumen sensitif secara lokal:

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

Dengan konteks 256K, model 31B dapat memproses dokumen hingga ~750 halaman — cukup untuk sebagian besar kontrak, makalah penelitian, dan dokumentasi teknis.

RAG Lokal (Retrieval-Augmented Generation)

Gabungkan Gemma 4 dengan database vektor lokal untuk sistem RAG yang sepenuhnya pribadi:

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# Gunakan Gemma 4 baik untuk embedding maupun generasi
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Buat vector store dari dokumen Anda
vectorstore = Chroma.from_documents(documents, embeddings)

# Query dengan RAG
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

Membangun Fitur AI ke dalam Aplikasi

Bagi pengembang yang membangun aplikasi dengan kemampuan AI, menjalankan Gemma 4 secara lokal melalui API Ollama adalah jalur tercepat menuju prototipe yang berfungsi. API yang kompatibel dengan OpenAI berarti Anda dapat memulai dengan Gemma 4 lokal untuk pengembangan dan beralih ke cloud APIs untuk produksi tanpa mengubah kode aplikasi.

Platform seperti ZBuild dapat menangani infrastruktur aplikasi — frontend, backend, autentikasi, database — sementara Anda fokus pada lapisan integrasi AI. Arahkan endpoint AI aplikasi Anda ke localhost:11434 selama pengembangan dan tukar ke endpoint cloud saat Anda siap untuk melakukan scaling.

Pemecahan Masalah

Kesalahan "Out of memory"

Jika Anda melihat kesalahan memori:

Coba kuantisasi yang lebih kecil: ollama pull gemma4:31b-q3_K_M
Kurangi context window: --num-ctx 4096
Tutup aplikasi intensif GPU lainnya
Beralih ke model yang lebih kecil: 26B MoE memberikan kualitas mendekati 31B dengan biaya memori lebih rendah

Kecepatan Generasi Lambat

Jika generasi lebih lambat dari yang diharapkan:

Periksa penggunaan GPU: nvidia-smi (seharusnya menunjukkan penggunaan GPU yang tinggi)
Pastikan model muat sepenuhnya di VRAM — offloading CPU sebagian secara dramatis lebih lambat
Kurangi --num-ctx untuk membebaskan VRAM bagi komputasi
Periksa apakah proses lain sedang menggunakan GPU

Model Tidak Ditemukan

Jika ollama run gemma4:26b-moe gagal:

# Daftar model yang tersedia
ollama list

# Cari model Gemma 4
ollama search gemma4

# Ambil model spesifik
ollama pull gemma4:26b-moe

Koneksi API Ditolak

Jika aplikasi tidak dapat terhubung ke localhost:11434:

# Periksa apakah Ollama sedang berjalan
ollama list

# Mulai server Ollama secara manual
ollama serve

# Periksa port
curl http://localhost:11434/api/tags

Pohon Keputusan Pemilihan Model

Gunakan ini untuk memilih model yang tepat dengan cepat:

Apakah Anda memiliki GPU dedikasi dengan 16GB+ VRAM?

Ya → Apakah Anda menginginkan kualitas maksimum atau efisiensi maksimum?
- Kualitas maksimum → gemma4:31b (Q4_K_M, butuh 20GB)
- Efisiensi maksimum → gemma4:26b-moe (Q4_K_M, butuh 18GB)
Tidak → Apakah Anda memiliki 8GB+ RAM?
- Ya → gemma4:e4b (Q4_K_M, kualitas lebih baik)
- Tidak → gemma4:e2b (Q4_K_M, berjalan pada 5GB)

Untuk sebagian besar pengembang dengan desktop modern atau PC gaming: Mulailah dengan gemma4:26b-moe. Model ini menawarkan rasio kualitas-ke-sumber daya terbaik di seluruh keluarga Gemma 4.

Apa yang Dapat Anda Bangun

Dengan Gemma 4 yang berjalan secara lokal, Anda memiliki backend AI tanpa biaya untuk:

Aplikasi chat dengan privasi percakapan penuh
Alat analisis kode yang bekerja pada codebase proprietary
Pipeline pemrosesan dokumen untuk data sensitif
Asisten AI lokal yang bekerja secara offline
Prototipe fitur AI sebelum berkomitmen pada biaya cloud API
Model yang di-fine-tune untuk tugas spesifik domain (Apache 2.0 mengizinkan ini secara bebas)

Lisensi Apache 2.0 berarti semua yang Anda bangun adalah milik Anda — tidak ada batasan penggunaan, tidak ada bagi hasil, tidak perlu persetujuan. Jalankan secara lokal, terapkan di server Anda, tanamkan dalam produk Anda. Inilah rupa AI yang benar-benar terbuka.

Jalankan Gemma 4 Secara Lokal dalam 5 Menit: Panduan Lengkap Pengaturan Ollama (2026)