Cara Menjalankan Gemma 4 Secara Lokal dengan Ollama: Panduan Lengkap

Ringkasan Singkat

Gemma 4 dirilis pada 3 April 2026, dan Ollama v0.20.0 menambahkan dukungan pada hari yang sama. Anda dapat menarik (pull) dan menjalankan model default gemma4:e4b dalam dua perintah. Panduan ini akan memandu Anda melalui pengaturan, pemilihan model, penggunaan API, dan cara menguji endpoint Gemma 4 lokal Anda dengan Apidog.

Pendahuluan

Google merilis Gemma 4 pada 2 April 2026. Dalam waktu 24 jam, Ollama mengirimkan v0.20.0 dengan dukungan penuh di keempat varian model.

Bagi pengembang, ini penting. Gemma 4 bukan peningkatan kecil. Ia mencetak 89,2% pada AIME 2026 dibandingkan dengan 20,8% milik Gemma 3. Skor benchmark pemrogramannya melonjak dari 110 ELO menjadi 2150 di Codeforces. Anda mendapatkan pemanggilan fungsi (function calling) secara native, mode berpikir (thinking modes) yang dapat dikonfigurasi, dan jendela konteks 256K pada varian yang lebih besar. Semua ini berjalan di perangkat keras Anda sendiri.

Jika Anda membangun aplikasi bertenaga API, pengaturan lokal membuka sesuatu yang berguna: lapisan AI yang cepat dan privat untuk menghasilkan data tiruan (mock data), menulis skenario pengujian, dan memvalidasi respons API tanpa mengirim data ke server jarak jauh.

Panduan ini mencakup segala hal mulai dari instalasi hingga membuat panggilan API lokal pertama Anda.

Apa yang baru di Gemma 4

Gemma 4 menyediakan empat varian model dengan kemampuan yang sangat berbeda.

Berikut adalah yang membedakannya dari Gemma 3:

Penalaran dan coding. Model 31B mencapai 80% pada LiveCodeBench v6. Gemma 3 27B sebelumnya mencetak 29,1%. Selisih tersebut bukanlah peningkatan bertahap; ini adalah kelas kinerja yang berbeda.

Arsitektur Mixture-of-Experts. Varian 26B menggunakan MoE dengan hanya 4 miliar parameter aktif selama inferensi. Anda mendapatkan kualitas mendekati flagship dengan sebagian kecil dari biaya komputasi.

Konteks lebih panjang. Model edge E2B dan E4B mendukung 128K token. Model 26B dan 31B memperluasnya hingga 256K, cukup untuk menampung basis kode besar atau file spesifikasi API dalam satu prompt.

Pemanggilan fungsi (function calling) native. Semua model Gemma 4 mendukung penggunaan alat terstruktur secara langsung. Anda dapat mendefinisikan skema fungsi dan model akan mengembalikan JSON yang valid sesuai dengan skema tersebut, tanpa memerlukan trik rekayasa prompt.

Input audio dan gambar. Model E2B dan E4B menerima input audio dan gambar resolusi variabel bersama dengan teks.

Mode berpikir. Anda dapat mengaktifkan atau menonaktifkan penalaran berantai-pikiran (chain-of-thought reasoning) model per permintaan. Untuk pencarian sederhana, lewati saja. Untuk masalah coding atau matematika yang kompleks, aktifkan.

Varian model Gemma 4 dijelaskan

Sebelum Anda menarik (pull) apa pun, pilih model yang tepat untuk perangkat keras Anda:

Model e4b adalah default ketika Anda menjalankan ollama run gemma4. Ini cocok untuk sebagian besar GPU konsumen dengan VRAM 10+ GB dan berjalan cukup cepat pada memori terpadu Apple Silicon.

Varian MoE 26b adalah pilihan tersembunyi (sleeper pick). Karena hanya 4 miliar parameter yang aktif per token, inferensi lebih dekat ke model 4B dalam kecepatan sementara kualitasnya mendekati model 13B. Jika Anda memiliki RAM 20+ GB, ini patut dicoba.

Prasyarat

Anda memerlukan Ollama v0.20.0 atau yang lebih baru. Versi sebelumnya tidak menyertakan dukungan Gemma 4.

Periksa versi Anda saat ini:

ollama --version

Jika Anda menggunakan versi yang lebih lama, perbarui:

# macOS
brew upgrade ollama

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

Di Windows, unduh installer terbaru dari ollama.com.

Persyaratan perangkat keras:

• gemma4:e2b: RAM minimal 8 GB (disarankan 16 GB)
• gemma4:e4b: VRAM 10 GB atau memori terpadu 16 GB
• gemma4:26b: RAM atau memori terpadu 20+ GB
• gemma4:31b: VRAM 24 GB atau memori terpadu 32 GB

Menginstal dan menjalankan Gemma 4

Tarik (pull) dan jalankan model e4b default:

ollama run gemma4

Ini mengunduh sekitar 9,6 GB pada jalankan pertama, lalu membawa Anda ke sesi interaktif. Ketik pesan untuk mengujinya:

>>> What are the HTTP status codes for client errors?

Untuk menjalankan varian tertentu:

# Model Edge, jejak lebih kecil
ollama run gemma4:e2b

# Model MoE, rasio kualitas-ke-ukuran terbaik
ollama run gemma4:26b

# Flagship penuh
ollama run gemma4:31b

Untuk menarik (pull) tanpa langsung menjalankan:

ollama pull gemma4
ollama pull gemma4:26b

Periksa model mana yang Anda miliki:

ollama list

Menggunakan API Gemma 4 secara lokal

Ollama mengekspos API REST lokal di http://localhost:11434. Setelah model ditarik (pull), Anda dapat memanggilnya dari klien HTTP mana pun tanpa memulai CLI interaktif.

Hasilkan penyelesaian (completion)

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Write a JSON response for a user profile API endpoint",
    "stream": false
  }'

Penyelesaian chat (endpoint yang kompatibel dengan OpenAI)

Ollama juga mendukung format chat OpenAI:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "Generate a realistic JSON mock for an e-commerce order API response"
      }
    ]
  }'

Klien Python

import requests

def ask_gemma4(prompt: str, model: str = "gemma4") -> str:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("List the fields a payment API response should include")
print(result)

Menggunakan OpenAI Python SDK

Karena API Ollama kompatibel dengan OpenAI, Anda dapat mengarahkan SDK resmi ke instans lokal Anda:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # required by the SDK but unused by Ollama
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "You generate realistic API response data in JSON format."
        },
        {
            "role": "user",
            "content": "Generate a sample response for a GET /users/{id} endpoint"
        }
    ]
)

print(response.choices[0].message.content)

Menggunakan pemanggilan fungsi (function calling) dengan Gemma 4

Gemma 4 mendukung pemanggilan fungsi (function calling) secara native. Anda mendefinisikan skema alat dan model mengembalikan JSON terstruktur yang sesuai dengan tanda tangan fungsi Anda.

Ini berguna untuk membangun agen yang memanggil API Anda secara terprogram:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "Retrieve a user by ID from the API",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "The unique user ID"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "Whether to include order history"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "Get user 42 with their order history"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}

Model mengekstrak parameter yang benar dari bahasa alami dan mengembalikan objek JSON yang valid sesuai dengan skema Anda. Tidak diperlukan parsing regex atau pembersihan output.

Mengaktifkan mode berpikir

Untuk tugas-tugas kompleks seperti menulis skenario pengujian atau menganalisis spesifikasi API, Anda dapat mengaktifkan penalaran berantai-pikiran (chain-of-thought reasoning) Gemma 4:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "Design a complete test scenario for a payment processing API with edge cases"
        }
    ],
    extra_body={"think": True}
)

print(response.choices[0].message.content)

Untuk permintaan yang lebih sederhana seperti menghasilkan satu nilai tiruan (mock value), lewati mode berpikir. Ini menambah latensi yang tidak Anda butuhkan.

Menguji respons API Gemma 4 dengan Apidog

Setelah instans Gemma 4 lokal Anda berjalan, Anda pasti ingin menguji endpoint API secara sistematis. Apidog menanganinya tanpa alat tambahan.

Impor spesifikasi API Ollama. Server lokal Ollama mengekspos endpoint REST standar. Buat proyek baru di Apidog dan tambahkan URL dasar http://localhost:11434.

Definisikan endpoint Anda. Tambahkan endpoint yang sedang Anda uji:

• POST /api/generate untuk penyelesaian sekali jalan
• POST /v1/chat/completions untuk chat multi-arah
• GET /api/tags untuk menampilkan daftar model yang tersedia

Siapkan Skenario Pengujian. Di Apidog, Skenario Pengujian merangkai beberapa permintaan dengan pernyataan (assertions) di antaranya. Untuk pengujian Gemma 4:

1. Langkah 1: GET /api/tags untuk memastikan bahwa gemma4 muncul dalam daftar model
2. Langkah 2: POST /api/generate untuk mengirim prompt dan memastikan bidang response tidak kosong
3. Langkah 3: POST /v1/chat/completions untuk mengirim pesan chat dan memastikan balasan sesuai dengan format yang Anda harapkan

Gunakan prosesor Extract Variable Apidog untuk menangkap respons dari langkah 2 dan meneruskannya ke langkah 3. Itu memungkinkan Anda menguji alur percakapan multi-arah secara otomatis.

Validasi skema respons. Pengujian Kontrak Apidog memvalidasi respons API terhadap spesifikasi OpenAPI Anda. Definisikan bentuk respons yang diharapkan untuk setiap endpoint Gemma 4, lalu jalankan pengujian kontrak setelah pembaruan model untuk menangkap setiap perubahan yang merusak dalam format API Ollama.

Smart Mock untuk pengembangan paralel. Jika backend Anda bergantung pada respons Gemma 4 tetapi Anda ingin tim frontend bekerja tanpa menunggu model lokal, Smart Mock Apidog menghasilkan respons yang sesuai skema dari spesifikasi API Anda secara otomatis. Definisikan seperti apa respons Gemma 4, dan Smart Mock menyajikan data realistis sesuai permintaan.

Input multimodal dengan Gemma 4

Model E2B dan E4B menerima gambar bersama dengan teks. Teruskan gambar sebagai string yang dienkode base64:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Describe the API flow shown in this diagram and identify potential error paths"
                }
            ]
        }
    ]
)

Ini berguna untuk menganalisis diagram arsitektur, meninjau tangkapan layar dokumentasi API, atau mengekstrak data dari gambar yang perlu diproses oleh API Anda.

Masalah umum dan perbaikan

Ollama mengatakan model tidak ditemukan. Jalankan ollama pull gemma4 terlebih dahulu, atau verifikasi dengan ollama list.

Inferensi lambat pada CPU. Gemma 4 dioptimalkan untuk GPU. Pada mesin hanya CPU, perkirakan 1-3 token per detik pada model e4b. Gunakan gemma4:e2b untuk kinerja CPU yang lebih baik.

Kesalahan kehabisan memori. Periksa VRAM atau memori terpadu yang tersedia dengan ollama ps. Jika model terlalu besar, beralihlah ke gemma4:e2b (7.2 GB).

Model tidak memuat di Apple Silicon. Ollama 0.20.0 menambahkan dukungan MLX untuk Apple Silicon dalam pratinjau. Jika Anda menggunakan versi Ollama yang lebih lama, perbarui terlebih dahulu.

Port sudah digunakan. Jika ada hal lain yang menggunakan port 11434, atur port kustom: OLLAMA_HOST=0.0.0.0:11435 ollama serve.

Respons terpotong. Tingkatkan jendela konteks dalam permintaan Anda: tambahkan "options": {"num_ctx": 8192} ke body JSON Anda.

Gemma 4 vs model lokal lainnya

Keunggulan Gemma 4 adalah varian MoE 26B. Dengan 18 GB, ia menghadirkan kualitas mendekati flagship dengan 4B parameter aktif pada waktu inferensi, memberi Anda token-per-detik yang lebih baik daripada model dense yang lebih besar mana pun dalam daftar ini.

Untuk tugas coding murni, model 31B kompetitif dengan model yang jauh lebih besar. Untuk penerapan edge atau laptop, e2b berjalan di bawah 8 GB.

Kesimpulan

Gemma 4 dengan Ollama adalah salah satu pengaturan lokal yang paling mumpuni yang tersedia saat ini. Instalasinya hanya memerlukan dua perintah. Model default berjalan di sebagian besar mesin pengembang. Dan peningkatan kualitas penalaran dan coding dibandingkan Gemma 3 sangat signifikan.

Mulai dengan ollama run gemma4, uji API dengan Apidog untuk memastikan endpoint Anda berfungsi seperti yang diharapkan, lalu pilih varian yang tepat untuk beban kerja Anda berdasarkan tabel model di atas.

Untuk tim yang membangun fitur bertenaga API di atas Gemma 4, menggabungkan inferensi lokal dengan Smart Mock dan Skenario Pengujian Apidog memberi Anda siklus pengembangan lengkap tanpa ketergantungan jarak jauh.

FAQ

Bagaimana cara memperbarui Gemma 4 di Ollama saat versi baru keluar?Jalankan ollama pull gemma4 lagi. Ollama akan memeriksa versi terbaru dan hanya mengunduh apa yang berubah.

Dapatkah saya menjalankan Gemma 4 di mesin tanpa GPU?Ya, tetapi lambat. Perkirakan 1-3 token per detik pada CPU. Model e2b adalah opsi paling praktis untuk mesin hanya CPU.

Apa perbedaan antara gemma4:e2b dan gemma4:e4b?Keduanya adalah model "efektif" dense yang dioptimalkan untuk perangkat keras edge. E4B memiliki lebih banyak parameter dan menangani penalaran kompleks dengan lebih baik. E2B lebih kecil dan mendukung input audio. Untuk sebagian besar tugas teks, e4b adalah default yang lebih baik.

Apakah Gemma 4 bekerja dengan LangChain dan LlamaIndex?Ya. Kedua framework mendukung Ollama sebagai backend. Arahkan penyedia Ollama ke http://localhost:11434 dan gunakan gemma4 sebagai nama model.

Apakah API Gemma 4 lokal kompatibel dengan kode yang ditulis untuk OpenAI API?Sebagian besar, ya. Endpoint /v1/chat/completions Ollama mengikuti format OpenAI. Alihkan base_url ke http://localhost:11434/v1 dan api_key ke string apa pun yang tidak kosong. Sebagian besar panggilan OpenAI SDK bekerja tanpa perubahan.

Bagaimana cara menggunakan mode berpikir Gemma 4?Lewatkan "think": true di parameter extra_body saat menggunakan OpenAI SDK, atau tambahkan "think": true ke body JSON tingkat atas dalam panggilan API langsung. Nonaktifkan untuk tugas sederhana untuk mengurangi latensi.

Dapatkah saya menyajikan Gemma 4 ke mesin lain di jaringan saya?Ya. Mulai Ollama dengan OLLAMA_HOST=0.0.0.0:11434 ollama serve dan mesin lain dapat mencapainya di alamat IP Anda pada port 11434.

Model Gemma 4 terbaik untuk tugas pengembangan API apa?Untuk menghasilkan data tiruan (mock data) dan menulis kasus pengujian, e4b adalah keseimbangan yang tepat antara kecepatan dan kualitas. Untuk analisis spesifikasi kompleks atau tinjauan arsitektur, model MoE 26b memberikan hasil yang lebih baik tanpa biaya model 31B penuh.