Cara Membangun AI Agent dengan Function Calling Gemma 4

Gemma 4 hadir dengan dukungan function calling native, yang berarti kamu bisa membangun AI agent yang tidak hanya menghasilkan teks — tapi mengambil tindakan. Panggil API, query database, cari web, jalankan kalkulasi. Panduan ini menunjukkan cara membangun agent yang berfungsi dari awal menggunakan Gemma 4 dan Python.

Apa Itu Function Calling?

Function calling memungkinkan model memutuskan kapan menggunakan tool eksternal alih-alih menebak jawaban. Alih-alih bertanya pada Gemma 4 "cuaca di Tokyo seperti apa?" dan mendapat respons halusinasi, model menghasilkan permintaan terstruktur untuk memanggil weather API-mu, kamu mengeksekusinya, memasukkan hasilnya kembali, dan model menghasilkan jawaban bahasa natural berdasarkan data nyata.

Alurnya seperti ini:

User: "Cuaca di Tokyo seperti apa?"
  → Model: {"function": "get_weather", "args": {"city": "Tokyo"}}
  → Kodemu memanggil weather API → return {"temp": 22, "condition": "sunny"}
  → Model: "Sekarang 22°C dan cerah di Tokyo."

Mendefinisikan Tool dengan JSON Schema

Pertama, kamu perlu memberi tahu Gemma 4 tool apa yang tersedia. Setiap tool didefinisikan dengan JSON schema yang mendeskripsikan nama, tujuan, dan parameternya:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city. Use this when the user asks about weather conditions.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name, e.g. 'Tokyo', 'New York'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Perform mathematical calculations. Use for any math the user asks about.",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "Math expression to evaluate, e.g. '2 + 2', 'sqrt(144)'"
                    }
                },
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web for current information. Use when the user asks about recent events or facts you're unsure about.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search query"
                    },
                    "num_results": {
                        "type": "integer",
                        "description": "Number of results to return (default: 3)"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

Deskripsi tool yang baik sangat penting. Model menggunakannya untuk memutuskan tool mana yang dipanggil dan kapan. Jadilah spesifik tentang kapan setiap tool harus digunakan.

Membangun Loop Agent

Berikut agent Python lengkap yang menggunakan Gemma 4 melalui API Ollama:

import json
import requests
import math

OLLAMA_URL = "http://localhost:11434/api/chat"
MODEL = "gemma4:12b"

# Definisikan implementasi tool-mu
def get_weather(city: str, unit: str = "celsius") -> dict:
    """Simulated weather API — replace with a real API call"""
    # In production, call OpenWeatherMap, WeatherAPI, etc.
    return {
        "city": city,
        "temperature": 22,
        "unit": unit,
        "condition": "sunny",
        "humidity": 45
    }

def calculate(expression: str) -> dict:
    """Safe math evaluation"""
    allowed_names = {
        "sqrt": math.sqrt,
        "sin": math.sin,
        "cos": math.cos,
        "pi": math.pi,
        "e": math.e,
        "abs": abs,
        "round": round
    }
    try:
        result = eval(expression, {"__builtins__": {}}, allowed_names)
        return {"expression": expression, "result": result}
    except Exception as e:
        return {"expression": expression, "error": str(e)}

def web_search(query: str, num_results: int = 3) -> dict:
    """Simulated web search — replace with real search API"""
    return {
        "query": query,
        "results": [
            {"title": f"Result about {query}", "snippet": "Relevant information..."}
        ]
    }

# Map nama fungsi ke implementasi
TOOL_MAP = {
    "get_weather": get_weather,
    "calculate": calculate,
    "web_search": web_search,
}

def call_gemma(messages: list, tools: list) -> dict:
    """Send a chat request to Gemma 4 via Ollama"""
    response = requests.post(OLLAMA_URL, json={
        "model": MODEL,
        "messages": messages,
        "tools": tools,
        "stream": False
    })
    return response.json()

def run_agent(user_input: str, tools: list, max_steps: int = 5):
    """Run the agent loop with multi-step tool use"""
    messages = [
        {
            "role": "system",
            "content": "You are a helpful assistant. Use the provided tools when needed. Always use tools for weather, calculations, and current information instead of guessing."
        },
        {"role": "user", "content": user_input}
    ]

    for step in range(max_steps):
        response = call_gemma(messages, tools)
        message = response["message"]

        # Cek jika model ingin memanggil tool
        if "tool_calls" in message and message["tool_calls"]:
            # Proses setiap tool call
            for tool_call in message["tool_calls"]:
                func_name = tool_call["function"]["name"]
                func_args = tool_call["function"]["arguments"]

                print(f"  → Calling {func_name}({func_args})")

                # Eksekusi tool
                if func_name in TOOL_MAP:
                    result = TOOL_MAP[func_name](**func_args)
                else:
                    result = {"error": f"Unknown tool: {func_name}"}

                # Tambahkan tool call dan hasilnya ke messages
                messages.append(message)
                messages.append({
                    "role": "tool",
                    "content": json.dumps(result)
                })
        else:
            # Model memberi respons teks final
            print(f"Agent: {message['content']}")
            return message["content"]

    return "Agent reached maximum steps without completing."

# Jalankan agent
if __name__ == "__main__":
    run_agent("Cuaca di Tokyo seperti apa dan berapa 15% dari 8500?", tools)

Agent ini bisa menangani query multi-langkah. Saat kamu bertanya "Cuaca di Tokyo seperti apa dan berapa 15% dari 8500?", Gemma 4 akan memanggil get_weather dan calculate secara terpisah, lalu menggabungkan kedua hasil menjadi satu respons natural.

Pola Agent Multi-Langkah

Agent nyata sering perlu merangkai beberapa tool call di mana call selanjutnya tergantung pada hasil sebelumnya:

# Contoh: "Temukan restoran dekat saya dan cek cuaca di sana"
# Langkah 1: Model panggil web_search("restoran dekat saya")
# Langkah 2: Model melihat hasil, panggil get_weather(kota dari hasil)
# Langkah 3: Model menggabungkan keduanya menjadi rekomendasi

# Loop agent menangani ini secara natural — setiap hasil tool
# ditambahkan ke percakapan, dan model memutuskan
# apa yang dilakukan selanjutnya berdasarkan riwayat penuh

Structured Output untuk Tool Use yang Reliable

Gemma 4 mendukung structured output, yang berarti kamu bisa memaksa model merespons dalam format JSON spesifik. Ini berguna saat kamu butuh jawaban akhir agent dalam struktur yang dapat dibaca mesin:

response = requests.post(OLLAMA_URL, json={
    "model": MODEL,
    "messages": messages,
    "format": {
        "type": "object",
        "properties": {
            "answer": {"type": "string"},
            "confidence": {"type": "number"},
            "sources": {
                "type": "array",
                "items": {"type": "string"}
            }
        },
        "required": ["answer", "confidence"]
    },
    "stream": False
})

Ini menjamin output adalah JSON valid yang cocok dengan schema-mu — tidak perlu lagi parsing teks bebas dan berharap yang terbaik.

Tips untuk Function Calling yang Lebih Baik

Tips	Mengapa
Tulis deskripsi tool yang detail	Model mengandalkan deskripsi untuk memilih tool yang tepat
Gunakan field `required` di schema	Mencegah model menghilangkan parameter kritis
Batasi jumlah tool ke 5-10	Terlalu banyak tool membingungkan model
Sertakan contoh dalam deskripsi	"e.g., 'New York', 'London'" membantu model memformat argumen dengan benar
Tangani error dengan baik	Kembalikan info error agar model bisa mencoba lagi atau memberi tahu user
Set batas max_steps	Mencegah infinite loop jika model terus memanggil tool

Kesalahan Umum

Model mengabaikan tool dan menjawab langsung: Buat system prompt secara eksplisit memberitahu model untuk menggunakan tool. Tambahkan "JANGAN PERNAH menebak cuaca/matematika/fakta — selalu gunakan tool yang disediakan."

Tipe argumen salah: Jika model mengirim "3" alih-alih 3 untuk parameter integer, tambahkan type coercion di implementasi tool-mu.

Model memanggil tool tidak perlu: Jadilah spesifik dalam deskripsi tool tentang kapan menggunakannya. "Gunakan HANYA saat user eksplisit menanyakan tentang cuaca" lebih baik dari "Dapatkan informasi cuaca."

Langkah Selanjutnya

Ingin mempelajari dasar-dasar API Ollama dulu? Cek Tutorial API Gemma 4 kami untuk pengenalan yang lebih lembut
Perlu memilih model yang tepat untuk beban kerja agent? Model 12B adalah sweet spot — lihat Model Gemma 4 Mana?
Membangun agent multimodal? Baca Panduan Multimodal untuk menambahkan kemampuan vision ke agent-mu

Function calling mengubah Gemma 4 dari chatbot menjadi tool sebenarnya. Setelah kamu menghubungkan API nyata — cuaca, pencarian, database, email — kamu punya AI agent yang bisa mengambil tindakan bermakna di dunia nyata, semua berjalan lokal di hardware-mu sendiri.

gemma4 — interact