Thanawat Wongchai

Posted on Apr 3 • Originally published at apidog.com

วิธีรัน Gemma 4 แบบ Local ด้วย Ollama: คู่มือฉบับสมบูรณ์

สรุปย่อ (TL;DR)

Gemma 4 เปิดตัวเมื่อวันที่ 3 เมษายน 2026 และ Ollama v0.20.0 ได้เพิ่มการรองรับในวันเดียวกัน คุณสามารถดึงและรันโมเดลเริ่มต้น gemma4:e4b ได้ด้วยคำสั่งเพียงสองคำสั่ง คู่มือนี้จะแนะนำคุณเกี่ยวกับการตั้งค่า การเลือกโมเดล การใช้งาน API และวิธีทดสอบ Gemma 4 endpoints ในเครื่องของคุณด้วย Apidog

ทดลองใช้ Apidog วันนี้

บทนำ

Google ได้เปิดตัว Gemma 4 เมื่อวันที่ 2 เมษายน 2026 ภายใน 24 ชั่วโมง Ollama ได้ออกเวอร์ชัน v0.20.0 พร้อมการรองรับเต็มรูปแบบสำหรับโมเดลทั้งสี่รูปแบบ

สำหรับนักพัฒนา Gemma 4 คือการอัปเกรดครั้งใหญ่: ทำคะแนน 89.2% ใน AIME 2026 เทียบกับ Gemma 3 ที่ได้ 20.8% และคะแนนการเขียนโค้ดเพิ่มจาก 110 ELO เป็น 2150 บน Codeforces คุณจะได้ฟีเจอร์ function calling, โหมดให้เหตุผลที่ปรับแต่งได้ และ context window สูงสุด 256K — ทั้งหมดนี้รันบนฮาร์ดแวร์ของคุณเอง

ถ้าคุณสร้างแอปที่ขับเคลื่อนด้วย API การรัน LLM ในเครื่องจะช่วยให้ได้เลเยอร์ AI ที่เร็วและปลอดภัยสำหรับ mock ข้อมูล, สร้าง test scenario, และตรวจสอบ API response โดยไม่ต้องส่งข้อมูลออกนอก

💡 เมื่อมี Gemma 4 ในเครื่องแล้ว Smart Mock ของ Apidog จะใช้ AI inference สร้าง mock API response ที่สมจริงจาก schema ของคุณโดยอัตโนมัติ แค่กำหนด API schema ครั้งเดียว Apidog จัดการ mock data ให้เอง เหมาะกับการทดลอง LLM ในเครื่องที่อยากได้ test data ตรง schema โดยไม่ต้องเขียน fixture เอง

คู่มือนี้จะสอนตั้งแต่การติดตั้งจนถึงการเรียกใช้งาน Gemma 4 API ในเครื่อง

มีอะไรใหม่ใน Gemma 4

Gemma 4 มีโมเดล 4 รุ่น ที่ตอบโจทย์ hardware และ use case ต่างกัน

จุดเด่นเมื่อเทียบกับ Gemma 3:

การให้เหตุผล/การเขียนโค้ด: 31B ทำคะแนน 80% ใน LiveCodeBench v6 (Gemma 3 27B ได้แค่ 29.1%)
Mixture-of-Experts (MoE): 26B ใช้ MoE เปิดใช้งานแค่ 4B parameters ต่อ inference คุณภาพใกล้เรือธงแต่เบาลงมาก
บริบทยาว: E2B/E4B รองรับ 128K tokens, 26B/31B รองรับ 256K
Function calling: ทุกโมเดลรองรับ native structured tool use รับ/คืน JSON ตรง schema โดยไม่ต้อง prompt engineering
รับอินพุตเสียง/รูป: E2B/E4B รองรับ input เสียงและรูปภาพ
Chain-of-Thought (CoT) mode: เปิด/ปิด reasoning per request ได้

คำอธิบายโมเดล Gemma 4 รุ่นต่างๆ

เลือกโมเดลให้เหมาะกับเครื่องของคุณ:

โมเดล	ขนาดบนดิสก์	บริบท	สถาปัตยกรรม	เหมาะสำหรับ
`gemma4:e2b`	7.2 GB	128K	Dense	แล็ปท็อป, edge, เสียง/รูป
`gemma4:e4b` (default)	9.6 GB	128K	Dense	นักพัฒนาส่วนใหญ่
`gemma4:26b`	18 GB	256K	MoE (4B active)	คุณภาพดีที่สุดต่อ GB
`gemma4:31b`	20 GB	256K	Dense	คุณภาพสูงสุด

e4b คือ default (ใช้ ollama run gemma4) เหมาะกับ GPU 10+GB VRAM หรือ Apple Silicon รวม 16GB RAM

26b (MoE) เหมาะกับ RAM 20+GB inference เร็วใกล้ 4B แต่คุณภาพเหมือน 13B

ข้อกำหนดเบื้องต้น

Ollama v0.20.0+ (เวอร์ชันก่อนหน้าไม่รองรับ Gemma 4)
ตรวจสอบเวอร์ชัน:

  ollama --version

อัปเดต Ollama:

  # macOS
  brew upgrade ollama

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

Windows: ดาวน์โหลดจาก ollama.com

Hardware:
- e2b: RAM 8GB+ (แนะนำ 16GB)
- e4b: VRAM 10GB หรือ Unified 16GB
- 26b: RAM/Unified 20GB+
- 31b: VRAM 24GB หรือ Unified 32GB

การติดตั้งและรัน Gemma 4

ดึงและรัน e4b (default):

ollama run gemma4

จะดาวน์โหลด ~9.6GB แล้วเข้าสู่ interactive prompt ลองพิมพ์:

>>> รหัสสถานะ HTTP สำหรับข้อผิดพลาดของไคลเอ็นต์คืออะไร?

รันรุ่นอื่น:

# Edge, ขนาดเล็ก
ollama run gemma4:e2b

# MoE (คุ้มคุณภาพ/ขนาด)
ollama run gemma4:26b

# Full flagship
ollama run gemma4:31b

ดึง model เฉยๆ (ไม่รัน):

ollama pull gemma4
ollama pull gemma4:26b

ลิสต์โมเดลที่มี:

ollama list

การใช้ Gemma 4 API ในเครื่อง

Ollama เปิด REST API ที่ http://localhost:11434 เรียกผ่าน HTTP client ได้เลย

สร้าง completion

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "เขียนการตอบสนอง JSON สำหรับ API endpoint โปรไฟล์ผู้ใช้",
    "stream": false
  }'

แชทแบบ OpenAI-compatible

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "สร้าง mock JSON ที่สมจริงสำหรับการตอบสนอง API คำสั่งซื้ออีคอมเมิร์ซ"
      }
    ]
  }'

ไคลเอนต์ 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("แสดงรายการฟิลด์ที่การตอบสนอง API การชำระเงินควรรวมถึง")
print(result)

ใช้ OpenAI Python SDK

Ollama API compatible กับ OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # จำเป็นโดย SDK แต่ไม่ได้ใช้โดย Ollama
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "คุณสร้างข้อมูลการตอบสนอง API ที่สมจริงในรูปแบบ JSON"
        },
        {
            "role": "user",
            "content": "สร้างตัวอย่างการตอบสนองสำหรับ endpoint GET /users/{id}"
        }
    ]
)

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

การใช้ Function Calling กับ Gemma 4

Gemma 4 รองรับ function calling แบบ native แค่กำหนด schema function/tool โมเดลจะส่งคืน JSON ตรงลายเซ็นของคุณ:

from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "เรียกผู้ใช้ด้วย ID จาก API",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "รหัสผู้ใช้ที่ไม่ซ้ำกัน"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "ว่าจะรวมประวัติคำสั่งซื้อหรือไม่"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "ดึงผู้ใช้ 42 พร้อมประวัติคำสั่งซื้อของเขา"}
    ],
    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}

โมเดลจะ extract parameter ตรงจากภาษาไทยและคืน JSON ตาม schema ไม่ต้อง regex/parse output เอง

การเปิดใช้งานโหมดการคิด

เหมาะกับงานให้เหตุผลเชิงซับซ้อน เช่น test scenario หรือวิเคราะห์ API spec:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "ออกแบบสถานการณ์การทดสอบที่สมบูรณ์สำหรับ API การประมวลผลการชำระเงินพร้อม edge cases"
        }
    ],
    extra_body={"think": True}
)

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

ถ้าแค่ mock ง่ายๆ ไม่ต้องเปิดโหมดนี้ (ลด latency)

การทดสอบการตอบสนอง Gemma 4 API ด้วย Apidog

เมื่อ Gemma 4 ในเครื่องทำงานแล้ว ทดสอบ endpoint ด้วย Apidog ได้ทันที

ขั้นตอน:

นำเข้าข้อกำหนด Ollama API: สร้างโปรเจกต์ใหม่ใน Apidog แล้วตั้ง base URL เป็น http://localhost:11434
กำหนด endpoint:
- POST /api/generate (completion)
- POST /v1/chat/completions (แชท)
- GET /api/tags (ลิสต์โมเดล)
ตั้ง test scenario:
1. GET /api/tags – เช็คว่า gemma4 อยู่ในโมเดล
2. POST /api/generate – ส่ง prompt แล้ว assert ว่า field response มีข้อมูล
3. POST /v1/chat/completions – ส่งแชทแล้วตรวจสอบว่าตรง format ที่ต้องการ

ใช้ Extract Variable ใน Apidog เพื่อ re-use response แต่ละ step ทดสอบ multi-turn flow ได้อัตโนมัติ

Contract Testing: เช็คว่า response ตรง OpenAPI spec ทุกครั้งหลังเปลี่ยน model
Smart Mock: กำหนด schema response ของ Gemma 4 แล้ว Smart Mock สร้าง mock data ให้ทีม front-end ใช้งานได้ทันที โดยไม่ต้องรอ LLM จริง

อินพุตแบบหลายโมดอลด้วย Gemma 4

E2B/E4B รับรูปภาพพร้อมข้อความ ส่งรูปเป็น base64 string:

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": "อธิบายโฟลว์ API ที่แสดงในแผนภาพนี้และระบุเส้นทางข้อผิดพลาดที่อาจเกิดขึ้น"
                }
            ]
        }
    ]
)

เหมาะกับการวิเคราะห์ diagram, ตรวจสอบ screenshot docs, หรือดึงข้อมูลจากรูปภาพ (input multimodal)

ปัญหาและการแก้ไขทั่วไป

Ollama แจ้งว่าไม่พบโมเดล: รัน ollama pull gemma4 หรือดูด้วย ollama list
Inference ช้าบน CPU: ใช้ e2b (7.2GB) สำหรับเครื่องไม่มี GPU
หน่วยความจำไม่พอ: ตรวจสอบ VRAM/Unified RAM ด้วย ollama ps ถ้าไม่พอให้ใช้ e2b
โมเดลไม่โหลดบน Apple Silicon: Ollama 0.20.0 ขึ้นไปเท่านั้น
พอร์ต 11434 ถูกใช้: ตั้งค่าพอร์ตเอง OLLAMA_HOST=0.0.0.0:11435 ollama serve
Response ตัดทอน: เพิ่ม context window "options": {"num_ctx": 8192} ใน payload

Gemma 4 เทียบกับโมเดลในเครื่องอื่นๆ

โมเดล	ขนาดที่เหมาะกับผู้ใช้ทั่วไป	บริบท	Function Calling	Benchmark Coding
Gemma 4	e4b (9.6 GB)	128K-256K	Native	80% LiveCodeBench
Llama 3.3	70B-Q4 (40 GB)	128K	Native	~60% LiveCodeBench
Qwen3.6-Plus	72B-Q4 (44 GB)	128K	Native	แข็งแกร่ง
Mistral Small	24B (14 GB)	128K	Native	ปานกลาง

จุดเด่น: Gemma 4 26B (MoE) ขนาด 18GB คุณภาพใกล้ flagship แต่ inference เร็วกว่า dense ใหญ่ๆ เหมาะกับ dev ส่วนมาก

31B เหมาะกับงานโค้ด, e2b เหมาะกับ edge/laptop (<8GB RAM)

สรุป

Gemma 4 + Ollama คือ LLM ในเครื่องที่ทรงพลัง ติดตั้งง่ายมาก (ollama run gemma4) ใช้ API ได้ทันที คุณภาพการ reasoning และ code generation สูงกว่า Gemma 3 แบบก้าวกระโดด

เริ่มด้วย e4b ทดสอบ API ด้วย Apidog ให้ endpoints ทำงานครบ เลือกรุ่นที่เหมาะกับงานจากตารางข้างบน

ถ้าสร้างระบบ API บน Gemma 4 จับคู่ inference ในเครื่องกับ Smart Mock และ Test Scenario ของ Apidog จะช่วยให้ dev cycle เร็วและไม่ง้อ resource ภายนอก

คำถามที่พบบ่อย (FAQ)

Q: อัปเดต Gemma 4 ใน Ollama ได้อย่างไร?

A: รัน ollama pull gemma4 Ollama จะโหลดเฉพาะ patch ใหม่

Q: รันบนเครื่องไม่มี GPU ได้ไหม?

A: ได้ แต่ช้า (~1-3 tokens/sec) ควรใช้ e2b สำหรับเครื่อง CPU-only

Q: gemma4:e2b กับ gemma4:e4b ต่างกันยังไง?

A: ทั้งคู่เป็น dense, e4b ใหญ่กว่า reasoning ดีกว่า, e2b เล็ก/รองรับเสียง

Q: ใช้กับ LangChain/LlamaIndex ได้ไหม?

A: ได้ ทั้งคู่รองรับ Ollama ชี้ endpoint เป็น http://localhost:11434, ใช้ gemma4 เป็นชื่อโมเดล

Q: Ollama API ในเครื่อง compatible กับ OpenAI API ไหม?

A: ส่วนใหญ่แล้ว ใช้ /v1/chat/completions เปลี่ยน base_url เป็น http://localhost:11434/v1 ใส่ api_key เป็นอะไรก็ได้

Q: เปิดโหมดการคิดยังไง?

A: ส่ง "think": true ใน extra_body (OpenAI SDK) หรือ JSON ตรงๆ

Q: ให้ Gemma 4 บริการเครื่องอื่นใน network ได้ไหม?

A: ได้ รัน OLLAMA_HOST=0.0.0.0:11434 ollama serve แล้วเครื่องอื่นเรียกที่ IP/PORt นี้

Q: เลือกโมเดลไหนสำหรับพัฒนา API?

A: mock/test case — ใช้ e4b, วิเคราะห์ spec/arch ซับซ้อน — 26b (MoE) คุ้มกว่า 31b

หมายเหตุ: ลิงก์ที่เกี่ยวข้อง Apidog ในโพสต์นี้จะถูกติดตามด้วย UTM สำหรับ dev.to

DEV Community