Google Rilis Agent Development Kit 1.0 untuk Kotlin: Akhirnya Setara Python

Selama dua tahun terakhir, setiap kali tim engineering ingin mengimplementasikan arsitektur AI Agent—mulai dari autonomous research agent, tool-calling pipelines, hingga orkestrasi multi-agent—opsi default yang masuk akal praktis hanya Python. Ekosistem seperti LangChain, LlamaIndex, CrewAI, dan AutoGen memonopoli tooling.

Bagi tim yang basis infrastruktur atau aplikasi kliennya berbasis JVM dan Kotlin (terutama tim Android dan backend Spring/Ktor), situasi ini menciptakan beban arsitektural yang menyebalkan: kita terpaksa membangun wrapper microservice Python terpisah hanya untuk mengeksekusi agent loop, atau menulis ratusan baris boilerplate HTTP client manual untuk menangani JSON schema tool calling.

Google akhirnya memecah friksi tersebut dengan merilis Agent Development Kit (ADK) 1.0 untuk Kotlin. Rilis ini bukan sekadar SDK wrapper tipis untuk Gemini API, melainkan framework agen first-class yang membawa fitur setara dengan implementasi Python dan Java: dukungan stateful memory, structured tool execution, dynamic orchestration, hingga integrasi on-device AI via Gemini Nano.

Mari kita bedah apa saja yang berubah di versi 1.0, bagaimana arsitekturnya bekerja di bawah kap mesin, dan implementasi kodenya secara praktikal.

Mengapa Rilis ADK 1.0 Kotlin Ini Krusial?

Dalam konteks software engineering enterprise dan aplikasi mobile skala besar, type safety dan performa konkurensi bukanlah fitur pelengkap—keduanya adalah fondasi. Pendekatan Python yang serba dinamis sering kali menimbulkan runtime error di tahap parsing tool call arguments saat LLM berhalusinasi menghasilkan skema yang tidak valid.

ADK 1.0 Kotlin menyelesaikan tiga problem struktural yang selama ini dihadapi developer JVM/Android:

1. Native Concurrency via Coroutines: Manajemen eksekusi paralel untuk multiple tool calling kini menggunakan suspend fun dan Kotlin Flow, bukan threading wrappers yang rawan memakan memory JVM.
2. Compile-Time Type Safety untuk Tools: Definisi fungsi dan skema parameter divalidasi langsung saat kompilasi lewat KSP (Kotlin Symbol Processing) dan kotlinx.serialization.
3. Unified Abstraction untuk On-Device & Cloud: Kode agen yang sama bisa dijalankan melawan model cloud (Gemini 1.5 Pro / Flash) maupun model lokal di perangkat (Gemini Nano via AICore di Android) tanpa merombak logika orkestrasi.

Arsitektur ADK 1.0: Komponen Utama di Bawah Kap Mesin

Google merancang ADK 1.0 di atas layer modular yang memisahkan antara model provider, memory layer, execution engine, dan interface aplikasi.

Berikut adalah komponen inti yang membentuk ADK 1.0:

1. Agent Engine & Session State

AgentEngine bertindak sebagai brain loop. Komponen ini bertanggung jawab membaca history, mengombinasikannya dengan system prompt, mengirimkan context window ke model, menerima response, dan mendeteksi apakah model meminta eksekusi tool (function call) atau memberikan jawaban final kepada user.

2. Type-Safe Tool Registry

Jika di Python kita mengandalkan docstring Pydantic untuk menjelaskan fungsi ke LLM, di ADK Kotlin kita menggunakan anotasi @Tool dan @ToolParam. KSP akan mengekstrak metadata tersebut menjadi JSON Schema standar yang dimengerti oleh Gemini pada saat kompilasi.

3. Memory & Context Management

ADK 1.0 menyediakan abstraksi MemoryStore bawaan:

• InMemorySessionStore: Untuk state ephemeral di memory.
• PersistentSessionStore: Interface untuk disambungkan ke database lokal (Room/SQLite di Android) atau data store terdistribusi (Redis/PostgreSQL di backend).

Hands-on: Membangun Tool-Calling Agent dengan Kotlin Coroutines

Mari kita bangun sebuah agen customer support teknis yang bisa mengecek status server dan melakukan restart service berdasarkan input natural language dari user.

1. Setup Dependency Gradle

Tambahkan artifact resmi ADK 1.0 ke dalam file build.gradle.kts Anda:

// build.gradle.kts
plugins {
    kotlin("jvm") version "2.0.21"
    kotlin("plugin.serialization") version "2.0.21"
    id("com.google.devtools.ksp") version "2.0.21-1.0.28"
}

dependencies {
    // Core ADK Kotlin
    implementation("com.google.ai.client.adk:adk-core:1.0.0")
    implementation("com.google.ai.client.adk:adk-gemini:1.0.0")
    
    // Kotlin Ecosystem
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
}

2. Mendefinisikan Toolset

Kita buat class service yang berisi tools. Setiap fungsi yang ingin diekspos ke model ditandai dengan anotasi @Tool.

// ServerTools.kt
package dev.vour.agent.tools

import com.google.ai.client.adk.annotation.Tool
import com.google.ai.client.adk.annotation.ToolParam
import kotlinx.serialization.Serializable

@Serializable
data class ServerStatus(
    val serverId: String,
    val isHealthy: Boolean,
    val cpuUsagePercent: Int,
    val activeErrors: List<String>
)

class ServerManagementTools {

    @Tool(description = "Mengecek status kesehatan server saat ini berdasarkan serverId.")
    suspend fun checkServerHealth(
        @ToolParam(description = "ID unik server, contoh: 'srv-prod-sg1'") 
        serverId: String
    ): ServerStatus {
        // Simulasi network call / query database internal
        return when (serverId) {
            "srv-prod-sg1" -> ServerStatus(serverId, false, 94, listOf("Out of Memory", "Socket Timeout"))
            else -> ServerStatus(serverId, true, 22, emptyList())
        }
    }

    @Tool(description = "Me-restart service tertentu pada server target.")
    suspend fun restartService(
        @ToolParam(description = "ID unik server") serverId: String,
        @ToolParam(description = "Nama service yang akan direstart, contoh: 'nginx', 'api-gateway'") serviceName: String
    ): String {
        // Logika restart service
        return "Service '$serviceName' pada server '$serverId' berhasil direstart pada status OK."
    }
}

3. Menginisialisasi dan Menjalankan Agent Loop

Sekarang kita inisialisasi model, daftarkan tool, dan jalankan session interaktif.

// Main.kt
package dev.vour.agent

import com.google.ai.client.adk.agent.Agent
import com.google.ai.client.adk.model.GeminiModel
import com.google.ai.client.adk.model.ModelConfig
import dev.vour.agent.tools.ServerManagementTools
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val apiKey = System.getenv("GEMINI_API_KEY") 
        ?: error("GEMINI_API_KEY environment variable tidak ditemukan!")

    // 1. Konfigurasi Model Provider
    val model = GeminiModel(
        apiKey = apiKey,
        modelName = "gemini-1.5-pro",
        config = ModelConfig(
            temperature = 0.2f, // Rendah untuk eksekusi tool yang presisi
            systemInstruction = """
                Anda adalah DevOps SRE Assistant otomatis.
                Tugas Anda adalah mendiagnosa keluhan performa sistem, memeriksa status server, 
                dan mengambil tindakan remediasi seperti restart service jika diperlukan.
                Selalu verifikasi kesehatan server sebelum dan sesudah tindakan.
            """.trimIndent()
        )
    )

    // 2. Registrasi Tools & Instansiasi Agent
    val devOpsAgent = Agent.builder()
        .setModel(model)
        .registerTools(ServerManagementTools())
        .build()

    // 3. Eksekusi Prompt
    val userPrompt = "Server srv-prod-sg1 dilaporkan lambat oleh tim QA. Tolong cek kondisinya, dan kalau ada masalah, restart service api-gateway."
    println("User: $userPrompt\n")

    val response = devOpsAgent.execute(userPrompt)

    println("Agent: ${response.finalAnswer}")
}

Penjelasan Baris demi Baris:

• Anotasi `@Tool` & `@ToolParam`: Menghilangkan kebutuhan untuk menulis schema JSON OpenAPI manual. ADK otomatis membuat schema representasi JSON yang disuntikkan ke API Gemini.
• `suspend fun` pada Tool: Engine ADK mendukung asynchronous tool execution secara out-of-the-box. Jika tool membutuhkan waktu lama (misalnya I/O database atau RPC), coroutine tidak memblokir thread pool utama.
• `Agent.builder()`: Mengikat model LLM, tool dispatcher, dan memori menjadi satu unit eksekusi terpadu. Saat model merespons dengan instruksi function call, dispatcher memetakan nama tool ke reflection invoker yang di-generate oleh KSP.

Alur Eksekusi Bolak-Balik: Message Lifecycle

Untuk memahami apa yang terjadi saat fungsi execute() dipanggil, diagram sekuens berikut menggambarkan siklus interaksi antara user, ADK Engine, Gemini LLM, dan fungsi lokal:

Orkestrasi Multi-Agent: Sequential dan Router Pattern

Di skala aplikasi yang lebih kompleks, satu model tidak ideal menangani semua domain tugas sekaligus (single-agent bottleneck). ADK 1.0 memperkenalkan kelas AgentRouter dan SequentialPipeline untuk mengorkestrasi beberapa agen spesialis.

Berikut contoh implementasi Supervisor Pattern di Kotlin:

// MultiAgentPipeline.kt
package dev.vour.agent.orchestration

import com.google.ai.client.adk.agent.Agent
import com.google.ai.client.adk.orchestration.AgentRouter
import com.google.ai.client.adk.model.GeminiModel

class DevOpsOrchestration(private val model: GeminiModel) {

    // Sub-Agent 1: Khusus Diagnosa
    val diagnosticAgent = Agent.builder()
        .setModel(model)
        .setName("DiagnosticSpecialist")
        .setDescription("Ahli menganalisa metrik server, CPU load, error logs, dan latency.")
        .build()

    // Sub-Agent 2: Khusus Remediasi & Eksekusi Script
    val remediationAgent = Agent.builder()
        .setModel(model)
        .setName("RemediationSpecialist")
        .setDescription("Bertanggung jawab merestart server, memutar rollback deployment, atau membersihkan cache.")
        .build()

    // Router / Supervisor Agent
    fun buildSupervisor(): AgentRouter {
        return AgentRouter.builder()
            .setSupervisorModel(model)
            .registerSubAgents(diagnosticAgent, remediationAgent)
            .setRoutingStrategy(AgentRouter.Strategy.DYNAMIC_INTENT)
            .build()
    }
}

Prinsip Penting: Jangan gabungkan puluhan tool ke dalam satu agen tunggal. Semakin banyak tool schema yang disuntikkan ke dalam satu context window, semakin tinggi probabilitas model salah memilih tool (tool selection hallucination). Pecah menjadi sub-agent dengan lingkup tanggung jawab yang terisolasi.

On-Device AI: Menjembatani Cloud Gemini dan Gemini Nano

Salah satu diferensiator terbesar ADK 1.0 Kotlin dibanding pustaka berbasis Python adalah kompatibilitasnya dengan Android AICore. Kita bisa menjalankan agen secara lokal di perangkat hardware (seperti Google Pixel atau perangkat flagship terbaru) tanpa mengirim data user ke cloud.

// OnDeviceAgentSetup.kt
package dev.vour.agent.android

import android.content.Context
import com.google.ai.client.adk.agent.Agent
import com.google.ai.client.adk.edge.GeminiNanoModel

class LocalAndroidAgent(private val context: Context) {

    suspend fun initLocalAssistant(): Agent {
        // Inisialisasi model on-device via AICore
        val nanoModel = GeminiNanoModel.builder(context)
            .setTemperature(0.1f)
            .build()

        return Agent.builder()
            .setModel(nanoModel)
            .build()
    }
}

Dengan integrasi ini, aplikasi Android dapat memproses data sensitif (seperti SMS, log lokal, atau file personal) menggunakan paradigma agentic workflow secara offline, privat, dan dengan latensi nol tanpa biaya API inference per token.

Gotchas & Anti-Patterns yang Wajib Dihindari

Saat mengadopsi ADK 1.0 Kotlin di production, perhatikan catatan teknis berikut agar tidak tersandung masalah stabilitas:

1. Memblokir Coroutine Context pada Custom Tools:

Anti-pattern: Menggunakan Thread.sleep() atau panggilan blocking I/O (seperti library HTTP berbasis Apache HttpClient synchronous) di dalam fungsi @Tool.

Solusi: Selalu gunakan suspend function yang non-blocking (withContext(Dispatchers.IO) atau Ktor Client) agar dispatcher coroutine ADK tidak mengalami thread starvation.

1. State Serialization Leak di Android:

Anti-pattern: Menyimpan instance AgentSession utuh ke dalam Android ViewModel state tanpa persistence serializer. Saat OS melakukan process death, state memory agen akan hilang.

Solusi: Gunakan custom PersistentSessionStore yang terintegrasi dengan Android Room Database atau DataStore.

1. Overloading Context Window pada On-Device Model:

Catatan: Gemini Nano memiliki batas ukuran konteks (context window) dan parameter yang lebih ketat dibanding Gemini 1.5 Flash/Pro. Hindari mendaftarkan tool dengan deskripsi parameter yang terlalu panjang atau mengembalikan JSON payload berukuran ratusan kilobyte ke model lokal.

Kesimpulan & Action Items

Kehadiran Google Agent Development Kit (ADK) 1.0 untuk Kotlin menandai berakhirnya era di mana arsitektur AI agent harus selalu bergantung pada runtime Python. Bagi developer JVM dan Android, ini adalah momen ideal untuk mengintegrasikan kapabilitas otonom langsung ke basis kode utama dengan keamanan tipe data, performa tinggi, dan arsitektur yang bersih.

Langkah Konkret untuk Tim Anda:

1. Audit Kebutuhan Agentic: Identifikasi endpoint atau microservice internal yang selama ini hanya bertindak sebagai glue code LLM.
2. Setup Proof of Concept (PoC): Pasang dependency adk-core 1.0 di repository Kotlin Anda, buat satu set fungsi @Tool, dan uji reliabilitas tool-calling dengan Gemini 1.5 Flash.
3. Eksplorasi On-Device: Jika Anda membangun aplikasi Android, uji kompatibilitas fallback antara Gemini Nano (on-device) dan Gemini Cloud untuk menghemat biaya inference API.