Tworzenie agentów ADK na Androida

Biblioteka Agent Development Kit (ADK) na Androida umożliwia tworzenie i integrowanie zaawansowanych agentów AI bezpośrednio w aplikacjach na Androida. ADK to platforma deweloperska typu open source do tworzenia agentów opartych na AI, którzy działają lokalnie, w usługach hostowanych i na urządzeniach mobilnych z Androidem. Platforma obsługuje języki programowania Kotlin i Java, dzięki czemu możesz szybko zacząć tworzyć agentów i skalować w górę do złożonych aplikacji z wieloma agentami.

Biblioteka ADK na Androida zapewnia specjalistyczne zależności i obsługę środowiska wykonawczego dostosowane do środowisk mobilnych. Możesz tworzyć agentów, którzy wykonują modele AI na urządzeniu za pomocą interfejsów ML Kit GenAI API, co pozwala tworzyć doświadczenia AI zorientowane na prywatność i o niskim opóźnieniu, które mogą działać bez dostępu do sieci.

Używanie ADK Kotlin w projektach na Androida

Za pomocą interfejsu ADK Kotlin agent API możesz tworzyć agentów AI, którzy działają w aplikacjach na Androida. Kod agenta, który napiszesz, jest identyczny z kodem w przewodniku dla początkujących ADK Kotlin Get started. Różnice dotyczą zależności Gradle, konfiguracji projektu i sposobu wywoływania agenta w czasie działania.

Wymagania wstępne

Biblioteka ADK na Androida ma te wymagania dotyczące programowania:

  • Android Studio
  • Android SDK (compileSdk 34 lub nowszy, minSdk 24 lub nowszy)

Konfigurowanie projektu aplikacji na Androida

W pliku build.gradle.kts projektu na Androida dodaj zależność ADK Android i procesor adnotacji KSP:

plugins {
    id("com.android.application")
    kotlin("android")
    id("com.google.devtools.ksp") version "2.1.20-2.0.1"
}

android {
    namespace = "com.example.agent"
    compileSdk = 34

    defaultConfig {
        applicationId = "com.example.agent"
        minSdk = 24
        targetSdk = 34
    }
}

dependencies {
    implementation("com.google.adk:google-adk-kotlin-core-android:0.1.0")
    ksp("com.google.adk:google-adk-kotlin-processor:0.1.0")
}

kotlin {
    jvmToolchain(17)
}

Definiowanie agenta

Kod agenta jest identyczny z kodem w krótkim wprowadzeniu do ADK Kotlin. Przykładowy kod HelloTimeAgent ze składnią @Tool, @Param i .generatedTools() działa bez modyfikacji na Androidzie:

package com.example.agent
import com.google.adk.kt.agents.Instruction
import com.google.adk.kt.agents.LlmAgent
import com.google.adk.kt.annotations.Param
import com.google.adk.kt.annotations.Tool
import com.google.adk.kt.models.Gemini
class TimeService {
    /** Mock tool implementation */
    @Tool
    fun getCurrentTime(
        @Param("Name of the city to get the time for") city: String
    ): Map<String, String> {
        return mapOf("city" to city, "time" to "The time is 10:30am.")
    }
}
object HelloTimeAgent {
    @JvmField
    val rootAgent = LlmAgent(
        name = "hello_time_agent",
        description = "Tells the current time in a specified city.",
        model = Gemini(
            name = "gemini-flash-latest",
            apiKey = System.getenv("GOOGLE_API_KEY")
                ?: error("GOOGLE_API_KEY environment variable not set."),
        ),
        instruction = Instruction(
            "You are a helpful assistant that tells the current time in a city. "
                + "Use the 'getCurrentTime' tool for this purpose."
        ),
        tools = TimeService().generatedTools(),
    )
}

Uruchamianie agenta z aplikacji na Androida

Na urządzeniach z Androidem użyj InMemoryRunner, aby wywołać agenta i zebrać odpowiedzi z współprogramu, jak pokazano w tym przykładzie kodu:

import com.google.adk.kt.runners.InMemoryRunner
import com.google.adk.kt.sessions.InMemorySessionService
import com.google.adk.kt.types.Content
import com.google.adk.kt.types.Part
import com.google.adk.kt.types.Role
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
// Create a runner and session service
val sessionService = InMemorySessionService()
val runner = InMemoryRunner(
    agent = HelloTimeAgent.rootAgent,
    sessionService = sessionService,
)
// Call the agent from a coroutine (e.g. in a ViewModel or Activity)
scope.launch {
    runner.runAsync(
        userId = "user-123",
        sessionId = "session-123",
        newMessage = Content(
            role = Role.USER,
            parts = listOf(Part(text = "What time is it in New York?")),
        ),
    ).collect { event ->
        val text = event.content?.parts?.firstOrNull()?.text
        if (!text.isNullOrBlank()) {
            // Update your UI with the agent's response
        }
    }
}

Modele na urządzeniu z Gemini Nano

Artefakt ADK na Androida obejmuje obsługę wnioskowania na urządzeniu za pomocą Gemini Nano przez interfejs ML Kit GenAI API. Dzięki temu agenci mogą działać bez dostępu do sieci, a dane pozostają na urządzeniu.

Aby użyć modelu na urządzeniu, utwórz model GenaiPrompt zamiast Gemini, jak pokazano w tym przykładzie kodu:

import com.google.adk.kt.models.mlkit.GenaiPrompt
import com.google.mlkit.genai.prompt.GenerativeModel
// Create an ML Kit GenerativeModel for on-device inference
val generativeModel: GenerativeModel = // ... initialize using ML Kit
val onDeviceModel = GenaiPrompt.create(
    generativeModel = generativeModel,
    name = "gemini-nano",
)
val agent = LlmAgent(
    name = "on_device_agent",
    model = onDeviceModel,
    instruction = Instruction("You are a helpful assistant."),
)

Możesz też łączyć modele w chmurze i na urządzeniu w systemie wieloagentowym: użyj Gemini działającego w chmurze jako głównego aranżera i modeli GenaiPrompt na urządzeniu dla sub-agentów, którzy wykonują zadania wymagające ochrony prywatności.

Aby zobaczyć pełną działającą aktywność i więcej przykładów, zapoznaj się z przykładami ADK Kotlin na GitHubie.