Cara Menjalankan Gemma 4 sebagai Backend API

Singkatnya: Google merilis Gemma 4 pada April 2026, sebuah keluarga empat model terbuka yang dilisensikan di bawah Apache 2.0 yang mengungguli model 20x ukurannya pada tolok ukur standar. Anda dapat memanggil API Gemma 4 melalui Google AI Studio, Vertex AI, atau menjalankannya secara lokal dengan Ollama dan vLLM. Pasangkan dengan Smart Mock Apidog untuk menghasilkan respons API realistis secara otomatis dari skema OpenAPI Anda tanpa menulis satu pun aturan mock.

Pendahuluan

Sebagian besar model AI sumber terbuka membuat Anda memilih: kemampuan mentah atau kemampuan untuk diterapkan. Anda mendapatkan model yang terlalu besar untuk dijalankan di laptop Anda, atau model kecil yang tidak dapat menangani penalaran multi-langkah. Gemma 4 mematahkan pertukaran itu.

Gemma 4 adalah keluarga model terbuka Google DeepMind yang paling mumpuni hingga saat ini. Model Dense 31B menempati peringkat ke-3 di antara semua model terbuka di papan peringkat Arena AI, mengalahkan pesaing 20x ukurannya. Model Mixture of Experts (MoE) 26B menempati posisi ke-6. Keduanya berjalan pada satu GPU 80GB. Model E2B dan E4B yang ringan berjalan sepenuhnya offline di ponsel dan perangkat edge.

Bagi pengembang API, ini lebih penting dari yang terlihat. Gemma 4 secara native mendukung pemanggilan fungsi, output JSON terstruktur, dan jendela konteks 256K. Itu menjadikannya pilihan praktis untuk membangun alat API bertenaga AI, mulai dari menghasilkan data uji hingga menulis mock hingga menganalisis respons API.

button

Apa itu Gemma 4 dan apa yang baru

Gemma 4 adalah generasi keempat model bahasa terbuka Google DeepMind. Nama "Gemma" berasal dari kata Latin untuk batu permata. Seri ini dimulai pada awal 2024, dan sejak diluncurkan, pengembang telah mengunduh model Gemma lebih dari 400 juta kali. Komunitas telah membangun lebih dari 100.000 varian, membentuk apa yang Google sebut "Gemmaverse."

Gemma 4 diluncurkan di bawah lisensi Apache 2.0, perubahan signifikan dari generasi sebelumnya yang menggunakan kebijakan penggunaan kustom. Ini berarti Anda dapat menggunakan, memodifikasi, dan mendistribusikan Gemma 4 secara komersial tanpa batasan. Ini adalah pergeseran berarti bagi perusahaan dan startup yang membutuhkan kontrol penuh atas infrastruktur AI mereka.

Peningkatan utama di Gemma 4 adalah apa yang Google sebut "kecerdasan-per-parameter." Model Dense 31B memberikan kemampuan tingkat terdepan dengan sebagian kecil dari biaya komputasi model seperti GPT-4 atau Claude 3 Sonnet. Pada papan peringkat teks Arena AI (per April 2026), Gemma 4 31B mengungguli model dengan 600B+ parameter.

Berikut adalah hal-hal yang benar-benar baru dibandingkan dengan Gemma 3:

Input multimodal native. Keempat model Gemma 4 memproses gambar dan video secara native. Model edge E2B dan E4B menambahkan input audio native untuk pengenalan suara. Ini bukan bagian dari kemampuan dasar Gemma 3.

Jendela konteks yang lebih panjang. Model E2B dan E4B mendukung 128K token. Model 26B dan 31B meluas hingga 256K token. Itu cukup untuk melewati seluruh repositori kode dalam satu prompt.

Dukungan alur kerja agen. Gemma 4 mencakup pemanggilan fungsi native, mode output JSON terstruktur, dan instruksi sistem. Ketiga fitur ini bersama-sama membuatnya praktis untuk membangun agen yang memanggil API eksternal, mengurai respons, dan merangkai tindakan bersama.

Penalaran tingkat lanjut. Model 31B menunjukkan peningkatan tolok ukur yang signifikan dalam matematika dan mengikuti instruksi multi-langkah dibandingkan dengan Gemma 3. Ini penting untuk generasi uji API, di mana Anda membutuhkan model untuk memahami hubungan antara titik akhir dan skema data.

Dukungan 140+ bahasa. Gemma 4 dilatih secara native pada lebih dari 140 bahasa, tidak diadaptasi dari bahasa Inggris. Ini membuatnya dapat digunakan untuk produk API global secara langsung.

Lisensi Apache 2.0. Seperti yang disebutkan, ini menghilangkan ambiguitas hukum untuk penggunaan komersial. Anda memiliki model Anda, data Anda, dan penerapan Anda.

Varian dan kemampuan model Gemma 4

Google merilis Gemma 4 dalam empat ukuran, masing-masing menargetkan tingkatan perangkat keras tertentu:

Model E2B dan E4B menggunakan arsitektur Mixture of Experts yang mengaktifkan hanya sebagian kecil dari total parameter per token. Ini menghemat masa pakai baterai dan RAM pada perangkat yang terbatas. Google membangunnya bekerja sama dengan Qualcomm dan MediaTek, dan mereka berjalan sepenuhnya offline di Android melalui Pratinjau Pengembang AICore.

Model 26B MoE mengaktifkan hanya 3.8B parameter selama inferensi meskipun memiliki total 26B parameter. Ini adalah opsi tercepat untuk penerapan sisi server di mana Anda menginginkan latensi rendah tanpa banyak mengorbankan kualitas.

Model Dense 31B adalah pemimpin kualitas. Ini adalah yang akan Anda pilih untuk fine-tuning pada tugas-tugas khusus domain, atau untuk kasus penggunaan apa pun di mana kualitas output lebih penting daripada kecepatan. Keempat varian dikirimkan dalam bentuk yang disetel instruksi (IT) dan dasar.

Untuk kasus penggunaan API, 26B MoE mencapai keseimbangan kecepatan/kualitas terbaik. 31B Dense adalah pilihan yang tepat ketika Anda membutuhkan output JSON terstruktur untuk respons API kompleks atau ketika Anda menghasilkan skenario uji dengan logika multi-langkah.

Semua model mendukung pemanggilan fungsi dan mode output JSON, yang merupakan dua kemampuan yang paling sering Anda gunakan saat membangun alat API dengan Gemma 4.

Menyiapkan API Gemma 4: langkah demi langkah

Anda memiliki tiga jalur utama untuk memanggil Gemma 4: Google AI Studio (tercepat), Vertex AI (perusahaan), atau penerapan lokal dengan Ollama atau vLLM. Berikut cara menyiapkan masing-masing.

Opsi 1: Google AI Studio (direkomendasikan untuk pembuatan prototipe)

Buka Google AI Studio dan buat akun gratis. Dari sana, hasilkan kunci API.

Instal SDK Google Generative AI:

pip install google-genai

Lakukan panggilan pertama Anda:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemma-4-31b-it")

response = model.generate_content(
    "Generate a JSON object for a user account with id, email, and created_at fields."
)

print(response.text)

Untuk output JSON terstruktur, gunakan parameter response_mime_type:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

prompt = """
Generate 3 sample user objects for an e-commerce API. 
Each user should have: id (integer), email (string), username (string), 
created_at (ISO 8601 timestamp), and subscription_tier (free|pro|enterprise).
Return as a JSON array.
"""

response = model.generate_content(prompt)
users = json.loads(response.text)
print(json.dumps(users, indent=2))

Opsi 2: Penerapan lokal dengan Ollama

Ollama memungkinkan Anda menjalankan Gemma 4 sepenuhnya di mesin Anda. Instal Ollama dari ollama.com, lalu tarik modelnya:

ollama pull gemma4

Jalankan server model:

ollama serve

Panggil dengan format API yang kompatibel dengan OpenAI:

import requests
import json

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "gemma4",
        "messages": [
            {
                "role": "user",
                "content": "Generate a valid JSON response for a REST API /products endpoint. Include id, name, price, and stock fields."
            }
        ],
        "stream": False
    }
)

result = response.json()
print(result["message"]["content"])

Opsi 3: Pemanggilan fungsi untuk orkestrasi API

Gemma 4 mendukung pemanggilan fungsi native. Ini memungkinkan Anda mendefinisikan alat yang dapat dipanggil model selama percakapan:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

# Define a tool that Gemma can call
tools = [
    {
        "function_declarations": [
            {
                "name": "get_api_schema",
                "description": "Retrieve the OpenAPI schema for a given endpoint path",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "endpoint_path": {
                            "type": "string",
                            "description": "The API endpoint path, e.g. /users/{id}"
                        },
                        "method": {
                            "type": "string",
                            "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
                        }
                    },
                    "required": ["endpoint_path", "method"]
                }
            }
        ]
    }
]

model = genai.GenerativeModel("gemma-4-31b-it", tools=tools)

response = model.generate_content(
    "I need to test the GET /users/{id} endpoint. What schema should the response follow?"
)

# Check if the model wants to call a function
if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call
    print(f"Model called function: {fc.name}")
    print(f"With args: {dict(fc.args)}")

Pola pemanggilan fungsi ini adalah yang membuat Gemma 4 berguna untuk membangun pipeline pengujian API agen.

Membangun mock API bertenaga AI dengan Gemma 4

Salah satu aplikasi Gemma 4 yang paling praktis untuk pengembang API adalah menghasilkan data mock. Saat Anda membangun frontend sebelum backend ada, atau menguji kasus-kasus tepi yang sulit dipicu dalam produksi, Anda membutuhkan respons mock yang realistis.

Berikut cara menggunakan Gemma 4 untuk menghasilkan data mock dari skema OpenAPI:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

# Your OpenAPI schema for the response
schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "order_number": {"type": "string", "pattern": "^ORD-[0-9]{6}$"},
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered", "cancelled"]},
        "total": {"type": "number", "minimum": 0},
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "integer"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "unit_price": {"type": "number"}
                }
            }
        },
        "created_at": {"type": "string", "format": "date-time"}
    }
}

prompt = f"""
Generate 5 realistic mock responses for an order management API.
Each response must conform exactly to this JSON Schema:
{json.dumps(schema, indent=2)}

Make the data realistic: use realistic prices, product IDs, and varied statuses.
Return as a JSON array of 5 order objects.
"""

response = model.generate_content(prompt)
mock_orders = json.loads(response.text)
print(json.dumps(mock_orders, indent=2))

Kuncinya di sini adalah Gemma 4 memahami batasan Skema JSON. Ini menghormati nilai enum, pola string, dan rentang numerik. Anda mendapatkan data mock yang benar-benar sesuai dengan kontrak API Anda, bukan string acak.

Anda dapat memperluas pola ini untuk menghasilkan data mock untuk titik akhir API apa pun. Masukkan skema respons dari spesifikasi OpenAPI Anda, dan Gemma 4 akan menghasilkan data uji yang sesuai skema.

Untuk mocking yang lebih canggih, gabungkan Gemma 4 dengan logika respons bersyarat. Jika permintaan berisi ID pengguna tertentu, kembalikan respons kesalahan. Jika tidak, kembalikan data keberhasilan. Di sinilah jendela konteks 256K Gemma 4 membantu: Anda dapat menyertakan seluruh spesifikasi OpenAPI Anda dalam prompt dan memintanya untuk menghasilkan respons mock untuk beberapa titik akhir sekaligus.

Satu alur kerja praktis: ekspor koleksi Apidog Anda sebagai spesifikasi OpenAPI, tempelkan ke dalam prompt, dan minta Gemma 4 untuk menghasilkan 10 kasus uji realistis per titik akhir. Anda mendapatkan set data mock lengkap dalam hitungan detik daripada jam.

Menguji respons API Gemma 4 dengan Apidog

Setelah Anda memiliki Gemma 4 yang menghasilkan data atau bertindak sebagai bagian dari pipeline API Anda, Anda perlu memverifikasi bahwa respons sesuai dengan skema Anda. Di sinilah fitur Skenario Pengujian Apidog berperan.

Berikut alur kerja spesifiknya:

Langkah 1: Impor titik akhir API Gemma 4 Anda ke Apidog.

Di Apidog, buka proyek Anda dan buat titik akhir baru. Atur URL ke API wrapper apa pun yang telah Anda bangun di sekitar Gemma 4 (atau arahkan langsung ke titik akhir Google AI Studio). Definisikan skema respons yang diharapkan di antarmuka Apidog.

Langkah 2: Gunakan Smart Mock untuk membuat prototipe respons yang diharapkan.

Sebelum menjalankan uji langsung terhadap Gemma 4, gunakan Smart Mock Apidog untuk menghasilkan respons dasar dari skema Anda. Smart Mock membaca spesifikasi respons Anda dan menghasilkan data realistis berdasarkan nama properti dan tipe. Bidang bernama email secara otomatis mendapatkan alamat email yang valid. Bidang bernama created_at mendapatkan stempel waktu yang diformat dengan benar.

Smart Mock menggunakan tiga lapisan prioritas: nilai bidang mock kustom terlebih dahulu, kemudian pencocokan nama properti (di mana ia menyimpulkan tipe data dari nama bidang), kemudian default Skema JSON. Hierarki ini berarti Anda dapat mengganti bidang tertentu sambil membiarkan mesin menangani sisanya.

Langkah 3: Buat Skenario Pengujian untuk pipeline Gemma 4 Anda.

Buka modul Pengujian di Apidog dan buat Skenario Pengujian baru. Tambahkan panggilan API Gemma 4 Anda sebagai langkah pertama. Kemudian tambahkan langkah-langkah asersi untuk memvalidasi respons.

Mode orkestrasi Skenario Pengujian Apidog memungkinkan Anda merangkai beberapa permintaan. Untuk uji integrasi API Gemma 4, skenario Anda mungkin terlihat seperti ini:

1. Panggil titik akhir autentikasi Anda untuk mendapatkan token
2. Kirim prompt ke Gemma 4 dengan token auth
3. Ekstrak JSON yang dihasilkan dari badan respons
4. Validasi JSON yang diekstrak terhadap asersi skema Anda
5. Lewatkan data yang divalidasi ke titik akhir POST hilir

Langkah 4: Siapkan asersi.

Pada langkah asersi, Anda dapat memeriksa kode status, header respons, dan bidang JSON. Untuk respons Gemma 4, Anda biasanya akan menyatakan bahwa bidang candidates[0].content.parts[0].text ada dan bahwa konten yang diurai sesuai dengan skema yang Anda harapkan.

Gunakan prosesor Ekstrak Variabel Apidog untuk menarik output Gemma 4 ke dalam variabel. Kemudian gunakan variabel itu dalam langkah permintaan berikutnya. Ini memungkinkan Anda merangkai data yang dihasilkan Gemma 4 melalui alur kerja uji multi-langkah.

Langkah 5: Jalankan dengan pengujian berbasis data.

Apidog mendukung file data uji CSV dan JSON. Anda dapat mendefinisikan 50 variasi prompt berbeda dalam CSV, mengimpornya ke Skenario Pengujian Anda, dan menjalankan semua 50 variasi dalam satu klik. Ini adalah cara Anda menguji bahwa integrasi Gemma 4 Anda menangani input yang beragam dengan benar.

Alur kerja lengkap dari definisi skema hingga eksekusi pengujian membutuhkan waktu sekitar 15 menit untuk disiapkan. Setelah itu, Anda dapat menjalankannya pada setiap commit melalui Apidog CLI di pipeline CI/CD Anda.

Kasus penggunaan dunia nyata

Generasi data uji API. Tim QA menghabiskan waktu signifikan menulis perlengkapan uji. Dengan mode output JSON Gemma 4 dan skema OpenAPI Anda, Anda dapat menghasilkan ratusan catatan uji realistis dalam hitungan menit. Masukkan skema, tentukan kasus tepi yang ingin Anda cakup, dan biarkan model menghasilkan datanya.

Mocking API Cerdas. Mock tradisional mengembalikan data statis. Dengan Gemma 4 di belakang server mock Anda, Anda dapat mengembalikan respons yang sesuai konteks. Mock untuk API pencarian produk dapat mengembalikan set produk yang berbeda berdasarkan kueri pencarian, bahkan tanpa meng-hardcode setiap kasus.

Generasi dokumentasi API. Jendela konteks 256K Gemma 4 memungkinkan Anda mengumpankan seluruh basis kode Anda ke dalam prompt. Minta untuk menghasilkan dokumentasi OpenAPI untuk titik akhir yang tidak terdokumentasi. Dukungan pemanggilan fungsi berarti Anda dapat membangun agen yang membaca file rute Anda dan secara otomatis menulis spesifikasi API.

Validasi skema respons. Saat mengkonsumsi API pihak ketiga, Anda ingin memvalidasi bahwa respons sesuai dengan harapan Anda. Gunakan Gemma 4 untuk menganalisis respons API dan menandai pelanggaran skema. Ini dapat menemukan bidang yang hilang, tipe yang salah, dan enum yang tidak konsisten lebih baik daripada validator Skema JSON sederhana.

Penulisan uji regresi otomatis. Berikan Gemma 4 spesifikasi API Anda dan daftar laporan bug. Minta untuk menulis kasus uji yang akan menangkap setiap bug. Karena ia memahami hubungan skema, ia dapat menulis uji non-trivial yang memeriksa transisi status dan dependensi bidang.

Gemma 4 vs model terbuka lainnya untuk penggunaan API

Bagaimana perbandingan Gemma 4 dengan model terbuka lainnya ketika tujuan Anda adalah membangun alat API?

Untuk kasus penggunaan API, fitur-fitur kritis adalah mode output JSON native, dukungan pemanggilan fungsi, dan panjang konteks. Gemma 4 31B dan 26B keduanya memiliki ketiganya.

Llama 3.3 70B adalah pesaing utama. Ini adalah model yang kuat, tetapi membutuhkan komputasi 2x lipat dari Gemma 4 31B untuk dijalankan. Pada papan peringkat Arena AI, Gemma 4 31B menempati peringkat di atas Llama 3.3 70B meskipun ukurannya separuh. Jika Anda menjalankan inferensi dalam skala besar, perbedaan dalam persyaratan GPU itu berarti langsung pada biaya infrastruktur.

Mistral 7B jauh lebih kecil dan lebih cepat, tetapi jendela konteks 32K membatasi kegunaannya untuk spesifikasi API besar. Ini juga tidak memiliki mode JSON native dan pemanggilan fungsi yang andal.

Qwen 2.5 72B adalah alternatif yang mumpuni, terutama untuk aplikasi multibahasa. Fitur alat API-nya sebanding dengan Gemma 4, tetapi membutuhkan perangkat keras yang jauh lebih banyak.

Lisensi Apache 2.0 pada Gemma 4 adalah keunggulan yang diremehkan. Llama menggunakan Lisensi Komunitas Llama, yang memiliki batasan pada penggunaan komersial tertentu. Jika Anda membangun produk di atas model terbuka, kejelasan hukum Apache 2.0 penting.

Untuk sebagian besar kasus penggunaan alat API: mulailah dengan Gemma 4 26B MoE untuk tugas yang sensitif terhadap latensi, atau Gemma 4 31B untuk output kualitas tertinggi.

Kesimpulan

Gemma 4 memberi pengembang alternatif terbuka yang kredibel untuk API AI berpemilik dalam membangun alat API. Lisensi Apache 2.0 menghilangkan friksi hukum yang membuat model terbuka sebelumnya rumit untuk dipasarkan secara komersial. Pemanggilan fungsi native dan mode output JSON membuatnya praktis untuk diintegrasikan ke dalam alur kerja API tanpa rekayasa prompt yang ekstensif.

Empat ukuran model mencakup setiap tingkatan perangkat keras mulai dari ponsel hingga workstation. Model 26B MoE adalah opsi yang menonjol untuk sebagian besar kasus penggunaan pengembangan API: ia memberikan kualitas hampir-terdepan dengan sebagian kecil dari biaya inferensi.

Pasangkan Gemma 4 dengan Apidog untuk menutup celah antara data yang dihasilkan AI dan validasi API. Gunakan Gemma 4 untuk menghasilkan data uji dan respons mock. Gunakan Smart Mock Apidog untuk membuat prototipe skema dan Skenario Pengujiannya untuk memvalidasi bahwa output AI memenuhi kontrak API Anda. Bersama-sama mereka membentuk alur kerja praktis untuk membangun dan menguji API bertenaga AI.

button

FAQ

Apa itu Gemma 4?Gemma 4 adalah keluarga model bahasa terbuka terbaru Google DeepMind, dirilis pada April 2026. Hadir dalam empat ukuran (E2B, E4B, 26B MoE, 31B Dense) dan dilisensikan di bawah Apache 2.0. Model 31B saat ini menempati peringkat ke-3 di antara semua model terbuka di papan peringkat teks Arena AI.

Apakah Gemma 4 gratis digunakan?Bobot model gratis untuk diunduh dan digunakan di bawah lisensi Apache 2.0. Anda membayar untuk komputasi saat Anda menjalankannya sendiri. Jika Anda menggunakan Google AI Studio, ada tingkat gratis dengan batasan laju. Vertex AI membebankan tarif komputasi Google Cloud standar.

Bisakah Gemma 4 menghasilkan JSON terstruktur?Ya. Gemma 4 mendukung parameter response_mime_type: "application/json" native melalui SDK Google Generative AI. Ini memaksa model untuk mengembalikan JSON yang valid setiap saat, yang penting untuk integrasi API di mana Anda mengurai output secara terprogram.

Bagaimana perbandingan Gemma 4 dengan GPT-4o untuk pengembangan API?GPT-4o adalah model berpemilik tanpa opsi penerapan lokal dan biaya API yang lebih tinggi. Gemma 4 31B gratis untuk diterapkan secara lokal, dan skor tolok ukurnya kompetitif dengan GPT-4o pada tugas penalaran. Untuk tim yang membutuhkan privasi data atau kontrol biaya, Gemma 4 layak dievaluasi secara serius.

Bisakah saya melakukan fine-tuning Gemma 4 dengan data API saya sendiri?Ya. Google mendukung fine-tuning Gemma 4 melalui Google AI Studio, Vertex AI, dan alat pihak ketiga seperti Hugging Face TRL. Fine-tuning pada skema API spesifik domain dan pola respons dapat secara signifikan meningkatkan kualitas output untuk kasus penggunaan khusus.

Perangkat keras apa yang saya perlukan untuk menjalankan Gemma 4 secara lokal?Model 31B dan 26B muat pada satu NVIDIA H100 80GB dalam bfloat16. Versi terkuantisasi berjalan pada GPU konsumen dengan VRAM 16-24GB. Model E4B dan E2B berjalan di ponsel dan perangkat edge, termasuk Raspberry Pi dan NVIDIA Jetson.

Apakah Gemma 4 mendukung pemanggilan fungsi?Ya, semua model Gemma 4 mendukung pemanggilan fungsi native. Anda mendefinisikan alat sebagai objek JSON dengan nama, deskripsi, dan skema parameter. Model memutuskan kapan harus memanggil alat dan meneruskan argumen terstruktur yang dapat Anda gunakan dalam kode.

Bagaimana cara menguji respons API Gemma 4 secara otomatis?Gunakan Skenario Pengujian Apidog untuk membangun alur kerja uji berantai. Impor titik akhir API Gemma 4 Anda, siapkan langkah-langkah permintaan, dan tambahkan asersi untuk memvalidasi struktur respons. Anda dapat menjalankan skenario secara lokal, melalui CLI, atau secara otomatis di pipeline CI/CD Anda pada setiap push kode.