Tutorial Lengkap Google Agent Development Kit (ADK): Membangun AI Agent dengan Python

Google Agent Development Kit (ADK) adalah framework open-source dari Google untuk membangun, mengelola, dan mengorkestrasi AI agent. Framework ini dirancang agar developer bisa membuat agent yang modular, composable, dan siap produksi. ADK terintegrasi langsung dengan ekosistem Google Cloud dan mendukung berbagai model LLM termasuk Gemini, Claude, dan GPT.

Dalam tutorial ini, kita akan mempelajari cara menggunakan Google ADK dari dasar hingga fitur lanjutan, lengkap dengan contoh kode yang bisa langsung dipraktekkan.

Mengapa Google ADK?

Sebelum masuk ke implementasi, penting untuk memahami keunggulan ADK dibanding framework agent lainnya:

• Multi-Agent Architecture: ADK mendukung orkestrasi multi-agent secara native, memungkinkan kamu membangun sistem agent yang kompleks dengan mudah
• Integrasi Google Cloud: Terintegrasi langsung dengan Vertex AI, Gemini API, dan layanan Google Cloud lainnya
• Model Agnostic: Meskipun dioptimalkan untuk Gemini, ADK bisa digunakan dengan model LLM apapun melalui LiteLLM
• Built-in Tools: Menyediakan tool bawaan untuk Google Search, code execution, dan banyak lagi
• Session Management: Sistem session dan memory management yang sudah terintegrasi
• Streaming Support: Mendukung streaming response untuk pengalaman pengguna yang lebih baik

Instalasi dan Setup

Persyaratan Sistem

Pastikan kamu sudah memiliki Python 3.9 atau lebih baru terinstal di sistem.

python --version  # Minimal Python 3.9

Instalasi ADK

Instal Google ADK menggunakan pip:

pip install google-adk

Untuk fitur tambahan seperti evaluasi dan deployment:

pip install google-adk[eval]
pip install google-adk[a2a]

Konfigurasi API Key

ADK membutuhkan API key untuk mengakses model LLM. Kamu bisa menggunakan Gemini API key atau Google Cloud credentials.

export GOOGLEAPIKEY="your-gemini-api-key"

export GOOGLECLOUDPROJECT="your-project-id"
export GOOGLECLOUDLOCATION="us-central1"
gcloud auth application-default login

Struktur Proyek

ADK menggunakan konvensi struktur folder tertentu. Buat struktur proyek berikut:

myagentproject/
├── myagent/

│   ├── init.py
│   └── agent.py
└── requirements.txt

from .agent import agent

# myagent/agent.py
from google.adk.agents import Agent

agent = Agent(
    model="gemini-2.0-flash",
    name="assistant",
    description="Agent asisten yang membantu menjawab pertanyaan",
    instruction="""Kamu adalah asisten AI yang ramah dan membantu.
    Jawab pertanyaan pengguna dengan jelas dan ringkas.
    Gunakan bahasa Indonesia jika pengguna bertanya dalam bahasa Indonesia.""",
)

Menjalankan Agent

Ada beberapa cara untuk menjalankan agent:

adk run myagent

adk web myagent

import asyncio
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService

async def main():
    sessionservice = InMemorySessionService()

    runner = Runner(
        agent=agent,
        appname="myapp",

        sessionservice=sessionservice,

    )

    session = await sessionservice.createsession(

        appname="myapp",

        userid="user1",

    )

    from google.genai.types import Content, Part

    response = runner.run(
        userid="user1",

        sessionid=session.id,
        newmessage=Content(

            role="user",
            parts=[Part(text="Apa itu machine learning?")]
        ),
    )

    async for event in response:
        if event.content and event.content.parts:
            for part in event.content.parts:
                if part.text:
                    print(part.text)

asyncio.run(main())

from google.adk.agents import Agent

def hitungbmi(beratkg: float, tinggicm: float) -> dict:
    """Menghitung Body Mass Index (BMI) seseorang.

    Args:
        beratkg: Berat badan dalam kilogram.

        tinggicm: Tinggi badan dalam sentimeter.

    Returns:
        Dictionary berisi nilai BMI dan kategorinya.
    """
    tinggim = tinggicm / 100
    bmi = beratkg / (tinggim * 2)


    if bmi < 18.5:
        kategori = "Berat badan kurang"
    elif bmi < 25:
        kategori = "Normal"
    elif bmi < 30:
        kategori = "Berat badan berlebih"
    else:
        kategori = "Obesitas"

    return {
        "bmi": round(bmi, 1),
        "kategori": kategori,
    }

def konversisuhu(nilai: float, dari: str, ke: str) -> dict:

    """Mengkonversi suhu antar satuan.

    Args:
        nilai: Nilai suhu yang akan dikonversi.
        dari: Satuan asal (celsius, fahrenheit, kelvin).
        ke: Satuan tujuan (celsius, fahrenheit, kelvin).

    Returns:
        Dictionary berisi hasil konversi.
    """
    if dari == "celsius":
        celsius = nilai
    elif dari == "fahrenheit":
        celsius = (nilai - 32)  5 / 9
    elif dari == "kelvin":
        celsius = nilai - 273.15
    else:
        return {"error": f"Satuan '{dari}' tidak dikenal"}

    if ke == "celsius":
        hasil = celsius
    elif ke == "fahrenheit":
        hasil = celsius  9 / 5 + 32

    elif ke == "kelvin":
        hasil = celsius + 273.15
    else:
        return {"error": f"Satuan '{ke}' tidak dikenal"}

    return {"hasil": round(hasil, 2), "satuan": ke}

agent = Agent(
    model="gemini-2.0-flash",
    name="calculatoragent",
    description="Agent kalkulator dengan berbagai fungsi perhitungan",
    instruction="Kamu adalah asisten kalkulator. Gunakan tool yang tersedia untuk membantu perhitungan.",
    tools=[hitungbmi, konversisuhu],
)

from google.adk.agents import Agent
from google.adk.tools import googlesearch, codeexecution

agent = Agent(
    model="gemini-2.0-flash",
    name="researchagent",

    description="Agent peneliti yang bisa mencari informasi di internet",
    instruction="""Kamu adalah peneliti AI. Gunakan Google Search untuk mencari
    informasi terbaru dan code execution untuk analisis data.""",
    tools=[googlesearch, codeexecution],

)

from google.adk.agents import Agent

translator = Agent(
    model="gemini-2.0-flash",
    name="translator",
    description="Menerjemahkan teks ke bahasa yang diminta",
    instruction="Kamu adalah penerjemah. Terjemahkan teks yang diberikan ke bahasa yang diminta.",
)

summarizer = Agent(
    model="gemini-2.0-flash",
    name="summarizer",
    description="Meringkas teks panjang menjadi poin-poin penting",
    instruction="Kamu adalah peringkas. Buat ringkasan singkat dari teks yang diberikan.",
)

agent = Agent(
    model="gemini-2.0-flash",
    name="contentprocessor",
    description="Agent utama yang memproses konten",
    instruction="""Kamu adalah pemroses konten. Gunakan translator untuk menerjemahkan
    dan summarizer untuk meringkas teks sesuai permintaan pengguna.""",
    tools=[translator, summarizer],
)

from google.adk.agents import SequentialAgent, Agent

agentpengumpul = Agent(

    model="gemini-2.0-flash",
    name="datacollector",
    description="Mengumpulkan data dari sumber yang diberikan",
    instruction="Kumpulkan dan organisir data dari input yang diberikan.",
)

agentanalis = Agent(

    model="gemini-2.0-flash",
    name="dataanalyst",
    description="Menganalisis data yang sudah dikumpulkan",
    instruction="Analisis data yang diberikan dan buat insight.",
)

agentpenulis = Agent(

    model="gemini-2.0-flash",
    name="reportwriter",
    description="Menulis laporan berdasarkan analisis",
    instruction="Tulis laporan lengkap berdasarkan analisis yang diberikan.",
)

agent = SequentialAgent(
    name="datapipeline",

    description="Pipeline analisis data otomatis",
    subagents=[agentpengumpul, agentanalis, agentpenulis],

)

from google.adk.agents import ParallelAgent, Agent

agentsentimen = Agent(
    model="gemini-2.0-flash",
    name="sentimentanalyzer",

    description="Menganalisis sentimen teks",
    instruction="Analisis sentimen teks: positif, negatif, atau netral.",
)

agenttopik = Agent(
    model="gemini-2.0-flash",
    name="topicextractor",

    description="Mengekstrak topik utama dari teks",
    instruction="Identifikasi topik-topik utama dari teks yang diberikan.",
)

agententitas = Agent(
    model="gemini-2.0-flash",
    name="entityextractor",

    description="Mengekstrak entitas dari teks",
    instruction="Identifikasi nama orang, organisasi, dan lokasi dari teks.",
)

agent = ParallelAgent(
    name="textanalyzer",
    description="Analisis teks secara paralel",
    subagents=[agentsentimen, agenttopik, agententitas],
)

from google.adk.agents import LoopAgent, Agent

agentpenulis = Agent(

    model="gemini-2.0-flash",
    name="writer",
    description="Menulis dan memperbaiki teks",
    instruction="""Tulis atau perbaiki teks berdasarkan feedback.
    Jika teks sudah baik, respond dengan 'SELESAI'.""",
)

agentreviewer = Agent(
    model="gemini-2.0-flash",
    name="reviewer",
    description="Mereview dan memberikan feedback pada teks",
    instruction="""Review teks dan berikan feedback untuk perbaikan.
    Jika teks sudah excellent, respond dengan 'APPROVED'.""",
)

agent = LoopAgent(
    name="writingloop",

    description="Loop penulisan dengan review iteratif",
    subagents=[agentpenulis, agentreviewer],
    maxiterations=3,

)

from google.adk.sessions import InMemorySessionService

sessionservice = InMemorySessionService()

session = await sessionservice.createsession(
    appname="myapp",
    userid="user1",
)

print(f"Session ID: {session.id}")

from google.adk.agents import Agent

def simpanpreferensi(key: str, value: str, toolcontext) -> str:
    """Menyimpan preferensi pengguna.

    Args:
        key: Nama preferensi.
        value: Nilai preferensi.
        toolcontext: Context tool (otomatis diisi oleh ADK).


    Returns:
        Konfirmasi penyimpanan.
    """
    toolcontext.state[key] = value
    return f"Preferensi '{key}' disimpan dengan nilai '{value}'"

def ambilpreferensi(key: str, toolcontext) -> str:
    """Mengambil preferensi pengguna.

    Args:
        key: Nama preferensi yang ingin diambil.
        toolcontext: Context tool (otomatis diisi oleh ADK).


    Returns:
        Nilai preferensi atau pesan error.
    """
    value = toolcontext.state.get(key)
    if value:
        return f"Preferensi '{key}': {value}"
    return f"Preferensi '{key}' tidak ditemukan"

agent = Agent(
    model="gemini-2.0-flash",
    name="preferenceagent",

    description="Agent yang mengingat preferensi pengguna",
    instruction="Bantu pengguna menyimpan dan mengambil preferensi mereka.",
    tools=[simpanpreferensi, ambilpreferensi],

)

from google.adk.sessions import DatabaseSessionService

sessionservice = DatabaseSessionService(
    dburl="postgresql://user:pass@localhost:5432/mydb"

)

from google.adk.agents import Agent
from google.genai.types import Content, Part

def contentfilter(callbackcontext, llmrequest):
    """Filter konten sensitif sebelum dikirim ke model."""
    usermessage = llmrequest.contents[-1]
    if usermessage and usermessage.parts:
        text = usermessage.parts[0].text.lower()

        blockedwords = ["hack", "exploit", "bypass"]
        for word in blockedwords:

            if word in text:
                return Content(
                    role="model",
                    parts=[Part(text="Maaf, saya tidak bisa membantu dengan permintaan tersebut.")]
                )
    return None

agent = Agent(
    model="gemini-2.0-flash",
    name="safeagent",
    description="Agent dengan content filtering",
    instruction="Jawab pertanyaan pengguna dengan aman.",
    beforemodelcallback=contentfilter,

)

def formatresponse(callbackcontext, llmresponse):
    """Format response model sebelum dikirim ke pengguna."""
    if llmresponse.content and llmresponse.content.parts:
        for part in llmresponse.content.parts:

            if part.text:
                part.text = part.text.strip()
                if not part.text.endswith((".", "!", "?")):
                    part.text += "."
    return llmresponse

agent = Agent(
    model="gemini-2.0-flash",
    name="formattedagent",

    description="Agent dengan response formatting",
    instruction="Jawab pertanyaan pengguna.",
    aftermodelcallback=formatresponse,
)

from google.adk.agents import Agent
from google.adk.models.litellm import LiteLlm


agentclaude = Agent(
    model=LiteLlm(model="anthropic/claude-sonnet-4-20250514"),
    name="claudeagent",

    description="Agent menggunakan Claude",
    instruction="Kamu adalah asisten yang menggunakan model Claude.",
)

agentgpt = Agent(
    model=LiteLlm(model="openai/gpt-4o"),
    name="gptagent",

    description="Agent menggunakan GPT-4",
    instruction="Kamu adalah asisten yang menggunakan model GPT-4.",
)

export ANTHROPICAPIKEY="your-anthropic-key"
export OPENAIAPIKEY="your-openai-key"

# customersupport/agent.py
from google.adk.agents import Agent

def caripesanan(nomorpesanan: str) -> dict:
    """Mencari informasi pesanan berdasarkan nomor pesanan.

    Args:
        nomorpesanan: Nomor pesanan pelanggan (format: ORD-XXXX).


    Returns:
        Dictionary berisi detail pesanan.
    """
    orders = {
        "ORD-1001": {
            "status": "Dikirim",
            "kurir": "JNE",
            "resi": "JP1234567890",
            "estimasi": "2-3 hari kerja",
        },
        "ORD-1002": {
            "status": "Diproses",
            "estimasi": "Akan dikirim dalam 24 jam",
        },
    }
    order = orders.get(nomorpesanan)
    if order:
        return {"found": True, *order}
    return {"found": False, "message": "Pesanan tidak ditemukan"}

def cariproduk(query: str) -> dict:

    """Mencari produk berdasarkan kata kunci.

    Args:
        query: Kata kunci pencarian produk.

    Returns:
        Dictionary berisi daftar produk yang cocok.
    """
    products = [
        {"nama": "Laptop Pro X", "harga": 15000000, "stok": 5},
        {"nama": "Mouse Wireless Z", "harga": 350000, "stok": 50},
        {"nama": "Keyboard Mech K", "harga": 1200000, "stok": 20},
    ]
    results = [p for p in products if query.lower() in p["nama"].lower()]
    return {"products": results, "total": len(results)}

def buattiket(subjek: str, deskripsi: str, prioritas: str) -> dict:
    """Membuat tiket support baru.

    Args:
        subjek: Subjek tiket.
        deskripsi: Deskripsi masalah.
        prioritas: Level prioritas (rendah, sedang, tinggi).

    Returns:
        Dictionary berisi informasi tiket yang dibuat.
    """
    return {
        "ticketid": "TKT-2001",

        "subjek": subjek,
        "prioritas": prioritas,
        "status": "Dibuat",
        "message": "Tiket berhasil dibuat. Tim kami akan menghubungi Anda dalam 1x24 jam.",
    }

agentpesanan = Agent(
    model="gemini-2.0-flash",
    name="orderagent",

    description="Menangani pertanyaan tentang pesanan dan pengiriman",
    instruction="""Kamu menangani pertanyaan tentang pesanan.
    Gunakan tool caripesanan untuk melihat status pesanan.
    Berikan informasi yang jelas dan ringkas.""",
    tools=[caripesanan],

)

agentproduk = Agent(
    model="gemini-2.0-flash",
    name="productagent",

    description="Menangani pertanyaan tentang produk dan katalog",
    instruction="""Kamu menangani pertanyaan tentang produk.
    Gunakan tool cariproduk untuk mencari produk.
    Berikan rekomendasi yang sesuai dengan kebutuhan pelanggan.""",
    tools=[cariproduk],

)

agentsupport = Agent(
    model="gemini-2.0-flash",
    name="supportagent",

    description="Menangani keluhan dan membuat tiket support",
    instruction="""Kamu menangani keluhan pelanggan.
    Gunakan tool buattiket untuk membuat tiket support.
    Tunjukkan empati dan berikan solusi.""",
    tools=[buattiket],

)

agent = Agent(
    model="gemini-2.0-flash",
    name="customersupport",
    description="Agent customer support utama",
    instruction="""Kamu adalah agent customer support utama.
    Arahkan pertanyaan ke sub-agent yang tepat:
Pertanyaan pesanan dan pengiriman -> orderagent

Pertanyaan produk dan katalog -> productagent
Keluhan dan masalah -> supportagent


    Sapa pelanggan dengan ramah dan profesional.
    Selalu gunakan bahasa Indonesia.""",
    tools=[agentpesanan, agentproduk, agentsupport],
)

Deployment dengan Vertex AI

Untuk deploy agent ke produksi menggunakan Vertex AI:

from google.adk.cli import deploy

deploy.deploytovertexai(

    agentmodule="customersupport",

    projectid="your-project-id",
    location="us-central1",
    displayname="Customer Support Agent",

)

adk deploy cloudrun \
    --project=your-project-id \
    --region=us-central1 \
    --appname=customer-support \

    customersupport

Best Practices

1. Instruction yang Jelas dan Spesifik

Tulis instruction yang detail dan spesifik untuk setiap agent. Semakin jelas instruction, semakin baik performa agent.

# Kurang baik
instruction = "Jawab pertanyaan."

Lebih baik
instruction = """Kamu adalah analis data senior.
Ketika menerima pertanyaan tentang data:
Identifikasi metrik yang relevan
Jelaskan trend yang terlihat
Berikan rekomendasi actionable
Format jawaban dalam poin-poin yang mudah dibaca."""

2. Dokumentasi Tool dengan Docstring

ADK menggunakan docstring fungsi untuk menjelaskan tool ke model. Pastikan docstring lengkap dengan deskripsi parameter dan return value.

3. Error Handling di Tools

Selalu tangani error di dalam tool function dan kembalikan pesan error yang informatif:

def fetchdata(url: str) -> dict:
    """Mengambil data dari URL.

    Args:
        url: URL sumber data.

    Returns:
        Dictionary berisi data atau pesan error.
    """
    try:
        import requests
        response = requests.get(url, timeout=10)
        response.raiseforstatus()

        return {"success": True, "data": response.json()}
    except requests.RequestException as e:
        return {"success": False, "error": str(e)}

from google.adk.evaluation import evaluate

results = evaluate(
    agent=agent,
    testcases=[
        {
            "input": "Berapa BMI saya? Berat 70 kg, tinggi 175 cm",
            "expectedtoolcalls": ["hitungbmi"],

            "expectedoutputcontains": ["Normal"],

        },
    ],
)

print(f"Pass rate: {results.passrate}%")

Kesimpulan

Google Agent Development Kit (ADK) menyediakan fondasi yang kuat untuk membangun AI agent di Python. Dengan dukungan multi-agent, tool management, session handling, dan integrasi Google Cloud, ADK cocok untuk membangun aplikasi AI dari prototipe hingga produksi.

Poin-poin penting yang perlu diingat:

• Mulai dengan agent sederhana dan tambahkan kompleksitas secara bertahap
• Manfaatkan multi-agent pattern untuk tugas kompleks
• Tulis instruction dan docstring yang jelas
• Gunakan session state untuk menjaga konteks
• Selalu test agent sebelum deploy ke produksi

Untuk informasi lebih lanjut, kunjungi dokumentasi resmi Google ADK dan contoh-contoh proyek di repository GitHub-nya. Selamat membangun AI agent!