Sebastian Petrus

Posted on Apr 3 • Originally published at apidog.com

Cách Chạy Gemma 4 Làm API Backend

TL;DR: Google đã phát hành Gemma 4 vào tháng 4 năm 2026, một dòng gồm bốn mô hình mã nguồn mở được cấp phép theo Apache 2.0, vượt trội hơn các mô hình lớn gấp 20 lần về kích thước trên các điểm chuẩn tiêu chuẩn. Bạn có thể gọi API Gemma 4 thông qua Google AI Studio, Vertex AI, hoặc chạy cục bộ với Ollama và vLLM. Kết hợp nó với Smart Mock của Apidog để tự động tạo phản hồi API thực tế từ các schema OpenAPI của bạn mà không cần viết bất kỳ quy tắc giả lập nào.

Dùng thử Apidog ngay hôm nay

Giới thiệu

Hầu hết các mô hình AI mã nguồn mở buộc bạn phải lựa chọn: khả năng thô hay khả năng triển khai. Bạn có thể có một mô hình quá lớn để chạy trên máy tính xách tay của mình, hoặc một mô hình nhỏ không thể xử lý suy luận nhiều bước. Gemma 4 đã phá vỡ sự đánh đổi đó.

Gemma 4 là dòng mô hình mã nguồn mở có khả năng nhất của Google DeepMind cho đến nay. Mô hình 31B Dense xếp hạng #3 trong số tất cả các mô hình mã nguồn mở trên bảng xếp hạng của Arena AI, đánh bại các đối thủ lớn gấp 20 lần. Mô hình 26B Mixture of Experts (MoE) giữ vị trí #6. Cả hai đều chạy trên một GPU 80GB duy nhất. Các mô hình E2B và E4B nhẹ có thể chạy hoàn toàn ngoại tuyến trên điện thoại và thiết bị biên.

Đối với các nhà phát triển API, điều này cực kỳ quan trọng. Gemma 4 hỗ trợ gọi hàm, đầu ra JSON có cấu trúc và cửa sổ ngữ cảnh 256K. Điều này làm cho nó trở thành một lựa chọn thực tế để xây dựng các công cụ API hỗ trợ AI, từ tạo dữ liệu kiểm thử đến viết mock và phân tích phản hồi API.

💡 Nếu bạn đang xây dựng với Gemma 4 và cần xác thực các phản hồi được tạo bởi AI đó dựa trên đặc tả OpenAPI của mình, công cụ Smart Mock của Apidog có thể tự động tạo các phản hồi giả lập phù hợp với schema từ định nghĩa API của bạn. Bạn không cần phải viết từng quy tắc mock; Smart Mock đọc schema của bạn và tạo dữ liệu phù hợp với ngữ cảnh ngay lập tức. Tải Apidog miễn phí và kết nối nó với quy trình làm việc API Gemma 4 của bạn.

Gemma 4 là gì và có gì mới

Gemma 4 là thế hệ thứ tư của các mô hình ngôn ngữ mở của Google DeepMind. Tên "Gemma" xuất phát từ tiếng Latin có nghĩa là đá quý. Dòng sản phẩm này bắt đầu vào đầu năm 2024 và kể từ khi ra mắt, các nhà phát triển đã tải xuống các mô hình Gemma hơn 400 triệu lần. Cộng đồng đã xây dựng hơn 100.000 biến thể, tạo thành cái mà Google gọi là "Gemmaverse."

Gemma 4 ra mắt dưới giấy phép Apache 2.0, một sự thay đổi đáng kể so với các thế hệ trước sử dụng chính sách sử dụng tùy chỉnh. Điều này cho phép sử dụng, sửa đổi và phân phối Gemma 4 cho mục đích thương mại mà không bị hạn chế.

Điểm nổi bật trong Gemma 4 là "trí thông minh trên mỗi tham số." Mô hình 31B Dense mang lại khả năng tiên tiến với chi phí tính toán thấp hơn nhiều so với các mô hình như GPT-4 hoặc Claude 3 Sonnet. Theo bảng xếp hạng văn bản Arena AI (tháng 4/2026), Gemma 4 31B vượt trội hơn các mô hình với hơn 600B tham số.

Những điểm mới so với Gemma 3:

Đầu vào đa phương thức tự nhiên: Cả bốn mô hình Gemma 4 đều xử lý hình ảnh, video và (ở E2B/E4B) cả âm thanh.
Cửa sổ ngữ cảnh dài hơn: E2B/E4B hỗ trợ 128K token, 26B/31B lên tới 256K token.
Hỗ trợ quy trình tác nhân: Gọi hàm tự nhiên, đầu ra JSON có cấu trúc, hướng dẫn hệ thống.
Suy luận nâng cao: 31B cải thiện rõ rệt các tác vụ toán học, tuân thủ lệnh nhiều bước.
Hỗ trợ 140+ ngôn ngữ: Gemma 4 được huấn luyện tự nhiên đa ngữ, không chỉ chỉnh sửa từ tiếng Anh.
Giấy phép Apache 2.0: Loại bỏ rào cản pháp lý cho mục đích thương mại.

Các biến thể và khả năng của mô hình Gemma 4

Gemma 4 có bốn kích thước, tối ưu cho từng cấp phần cứng:

Mô hình	Tham số	Tham số hoạt động (suy luận)	Ngữ cảnh	Tốt nhất cho
E2B	2B hiệu quả	~2B	128K	Di động, IoT, thiết bị biên
E4B	4B hiệu quả	~4B	128K	Điện thoại, Raspberry Pi, Jetson
26B MoE	Tổng 26B	~3.8B	256K	Tác vụ máy chủ, độ trễ thấp
31B Dense	31B	31B	256K	Chất lượng cao, tinh chỉnh, nghiên cứu

E2B/E4B dùng kiến trúc MoE, chỉ kích hoạt một phần nhỏ tham số, tiết kiệm pin và RAM, chạy hoàn toàn offline trên Android (AICore).
26B MoE kích hoạt 3.8B tham số trong quá trình suy luận, lý tưởng cho server latency-sensitive.
31B Dense cho chất lượng đầu ra tốt nhất, phù hợp tinh chỉnh hoặc các trường hợp yêu cầu chất lượng cao.
Cả bốn đều có bản "hướng dẫn" (IT) và "cơ sở" (base), đều hỗ trợ gọi hàm và JSON output.

Thiết lập API Gemma 4: từng bước một

Bạn có ba lựa chọn chính để gọi Gemma 4: Google AI Studio, Vertex AI, hoặc triển khai cục bộ với Ollama/vLLM.

Tùy chọn 1: Google AI Studio (khuyên dùng cho tạo mẫu nhanh)

Đăng ký tài khoản miễn phí tại Google AI Studio.
Tạo khóa API.
Cài đặt SDK:
```
pip install google-genai
```

Thực hiện gọi API đầu tiên:

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)

Để xuất JSON có cấu trúc, sử dụng tham số 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))

Tùy chọn 2: Triển khai cục bộ với Ollama

Cài đặt Ollama từ ollama.com.
Tải mô hình:
```
ollama pull gemma4
```
Chạy máy chủ mô hình:
```
ollama serve
```

Gọi API tương thích 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"])

Tùy chọn 3: Gọi hàm để điều phối API

Gemma 4 hỗ trợ gọi hàm tự nhiên, cho phép bạn định nghĩa các công cụ mà mô hình có thể gọi trực tiếp:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

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?"
)

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)}")

Xây dựng mock API hỗ trợ AI với Gemma 4

Bạn có thể tận dụng Gemma 4 để tạo dữ liệu mock thực tế cho API chỉ từ schema OpenAPI. Ví dụ:

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"}
)

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))

Gemma 4 hiểu và tuân thủ các ràng buộc của JSON Schema: enum, pattern, min/max, v.v. Bạn chỉ cần cung cấp schema, mô hình sẽ sinh dữ liệu kiểm thử hợp lệ cho mọi endpoint.

Để tạo mock nâng cao hơn, bạn có thể kết hợp logic phản hồi có điều kiện (ví dụ: trả về lỗi nếu user_id nhất định), hoặc dán toàn bộ đặc tả OpenAPI vào prompt và yêu cầu Gemma 4 tạo dữ liệu kiểm thử hàng loạt.

Một quy trình thực tế: xuất bộ sưu tập Apidog của bạn dưới dạng OpenAPI, dán vào prompt, và yêu cầu Gemma 4 sinh 10 trường hợp kiểm thử cho mỗi endpoint.

Kiểm thử phản hồi API Gemma 4 với Apidog

Khi bạn đã có Gemma 4 sinh dữ liệu hoặc đóng vai trò trong pipeline API, hãy xác thực phản hồi bằng kịch bản kiểm thử của Apidog.

Quy trình làm việc:

Bước 1: Nhập endpoint API Gemma 4 vào Apidog. Tạo endpoint mới, định nghĩa schema phản hồi mong đợi.

Bước 2: Sử dụng Smart Mock để tạo phản hồi mẫu nhanh từ schema. Smart Mock tự động sinh dữ liệu thực tế dựa trên tên trường và kiểu dữ liệu, ví dụ email sẽ là email hợp lệ, created_at sẽ là timestamp đúng chuẩn.

Smart Mock ưu tiên: giá trị tùy chỉnh > khớp tên thuộc tính > mặc định JSON Schema.

Bước 3: Tạo Kịch bản Kiểm thử cho pipeline của bạn:

Gọi endpoint xác thực lấy token
Gửi prompt đến Gemma 4 kèm token
Trích xuất JSON từ phản hồi
Xác thực JSON với schema
Gửi dữ liệu đã xác thực tới endpoint POST tiếp theo

Bước 4: Thiết lập xác nhận: kiểm tra mã trạng thái, headers, các trường JSON. Dùng bộ xử lý Trích xuất Biến của Apidog để lấy output của Gemma 4 vào biến và sử dụng trong các bước tiếp theo.

Bước 5: Kiểm thử dựa trên dữ liệu: nhập file CSV/JSON chứa nhiều biến thể prompt, chạy hàng loạt kiểm thử chỉ với một cú nhấp.

Toàn bộ quy trình từ định nghĩa schema đến thực thi kiểm thử có thể thiết lập trong 15 phút và tự động hoá qua Apidog CLI trong pipeline CI/CD.

Các trường hợp sử dụng thực tế

Tạo dữ liệu kiểm thử API: Sinh hàng trăm bản ghi kiểm thử thực tế từ schema chỉ trong vài phút.
Mock API thông minh: Trả về phản hồi động, phù hợp ngữ cảnh và truy vấn.
Tạo tài liệu API: Đưa toàn bộ codebase vào prompt, nhờ Gemma 4 viết đặc tả OpenAPI tự động.
Xác thực schema phản hồi: Dùng Gemma 4 để phân tích phản hồi API, phát hiện vi phạm schema, trường thiếu, kiểu dữ liệu sai, enum không nhất quán.
Viết kiểm thử hồi quy tự động: Đưa đặc tả API và danh sách bug, yêu cầu Gemma 4 sinh case test để bao phủ các lỗi đó.

Gemma 4 so với các mô hình mở khác để sử dụng API

Mô hình	Tham số	Ngữ cảnh	Đầu ra JSON	Gọi hàm	Giấy phép
Gemma 4 31B	31B	256K	Tự nhiên	Tự nhiên	Apache 2.0
Gemma 4 26B MoE	26B (3.8B active)	256K	Tự nhiên	Tự nhiên	Apache 2.0
Llama 3.3 70B	70B	128K	Qua prompt	Qua prompt	Llama Community
Mistral 7B	7B	32K	Qua prompt	Hạn chế	Apache 2.0
Qwen 2.5 72B	72B	128K	Tự nhiên	Tự nhiên	Apache 2.0

Gemma 4 31B/26B nổi bật nhờ hỗ trợ JSON output và gọi hàm tự nhiên, cửa sổ ngữ cảnh lớn, giấy phép rõ ràng.
Llama 3.3 70B mạnh nhưng đòi hỏi tài nguyên gấp đôi Gemma 4 31B và giấy phép hạn chế thương mại.
Mistral 7B nhẹ, rẻ nhưng cửa sổ ngữ cảnh nhỏ và không hỗ trợ JSON, gọi hàm tốt.
Qwen 2.5 72B đa ngữ, mạnh, nhưng yêu cầu phần cứng rất lớn.

Khuyến nghị: dùng Gemma 4 26B MoE cho latency-sensitive, Gemma 4 31B cho chất lượng cao.

Kết luận

Gemma 4 là lựa chọn mở mạnh mẽ cho các nhà phát triển API, thay thế xứng đáng cho các API AI độc quyền. Giấy phép Apache 2.0 rõ ràng, hỗ trợ gọi hàm tự nhiên và JSON output, phù hợp tích hợp trực tiếp vào quy trình phát triển API. Bốn kích thước mô hình đáp ứng mọi cấp phần cứng. 26B MoE là lựa chọn tối ưu cho đa số trường hợp sử dụng phát triển API.

Kết hợp Gemma 4 và Apidog để hoàn thiện vòng lặp tạo dữ liệu kiểm thử và xác thực API. Sử dụng Gemma 4 cho dữ liệu kiểm thử, phản hồi mock; dùng Smart Mock và Kịch bản Kiểm thử Apidog để xác thực output AI với hợp đồng API của bạn. Quy trình này giúp xây dựng và kiểm thử API hỗ trợ AI thực tế, hiệu quả.

Câu hỏi thường gặp

Gemma 4 là gì?

Gemma 4 là dòng mô hình ngôn ngữ mở mới nhất của Google DeepMind, phát hành tháng 4/2026. Có bốn kích thước (E2B, E4B, 26B MoE, 31B Dense), giấy phép Apache 2.0. 31B hiện xếp hạng #3 trên Arena AI.

Gemma 4 có miễn phí không?

Trọng số mô hình tải và sử dụng miễn phí theo Apache 2.0. Nếu chạy trên Google AI Studio thì có free tier; Vertex AI tính phí theo tài nguyên.

Gemma 4 có xuất JSON có cấu trúc không?

Có. Hỗ trợ response_mime_type: "application/json" tự nhiên qua SDK, luôn trả về JSON hợp lệ cho các case dùng API.

Gemma 4 so sánh với GPT-4o thế nào cho phát triển API?

GPT-4o là mô hình độc quyền, không triển khai cục bộ, chi phí API cao hơn. Gemma 4 31B có thể triển khai miễn phí cục bộ, benchmark cạnh tranh GPT-4o cho nhiều tác vụ. Phù hợp nhóm cần quyền riêng tư và kiểm soát chi phí.

Có thể tinh chỉnh Gemma 4 trên dữ liệu API riêng không?

Có. Google hỗ trợ tinh chỉnh qua AI Studio, Vertex AI, Hugging Face TRL. Tinh chỉnh trên schema và phản hồi API miền giúp tăng chất lượng output.

Cần phần cứng gì để chạy Gemma 4 cục bộ?

31B/26B phù hợp trên GPU NVIDIA H100 80GB (bfloat16); bản lượng tử hóa chạy trên GPU 16-24GB VRAM. E4B/E2B chạy trên điện thoại, Raspberry Pi, Jetson.

Gemma 4 hỗ trợ gọi hàm không?

Có, tất cả các biến thể đều hỗ trợ gọi hàm tự nhiên, định nghĩa dưới dạng JSON với tên, mô tả, schema tham số.

Kiểm thử phản hồi API Gemma 4 tự động thế nào?

Dùng Kịch bản Kiểm thử Apidog để xây dựng chuỗi kiểm thử, nhập endpoint Gemma 4, thiết lập request/validate, chạy tự động cục bộ hoặc trong CI/CD với CLI.

DEV Community