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 open source dla programistów 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 udostępnia specjalistyczne zależności i obsługę środowiska wykonawczego dostosowane do środowisk mobilnych. Za pomocą interfejsów ML Kit GenAI możesz tworzyć agenty, które wykonują modele AI na urządzeniu przy użyciu Gemini Nano. Umożliwia to tworzenie funkcji AI, które działają bez dostępu do sieci, zapewniają prywatność i mają małe opóźnienia.

Używanie pakietu ADK Kotlin w projektach na Androida

Za pomocą interfejsu ADK Kotlin agent API możesz tworzyć agenty AI, które działają w aplikacjach na Androida. Kod agenta, który napiszesz, jest identyczny z kodem w przewodniku Rozpoczęcie pracy dotyczącym pakietu ADK w języku Kotlin. 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)
}

Zdefiniuj agenta

Kod agenta jest identyczny z kodem w szybkim wprowadzeniu do pakietu ADK w Kotlinie. Przykład kodu z syntaktyką @Tool, @Param i .generatedTools() działa na Androidzie bez modyfikacji:HelloTimeAgent

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 poziomu aplikacji na Androida

Na urządzeniach z Androidem użyj InMemoryRunner, aby wywołać agenta i zbierać 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 obsługuje wnioskowanie na urządzeniu za pomocą Gemini Nano przez interfejs ML Kit GenAI API. Dzięki temu agenty mogą działać bez dostępu do sieci, a dane są przechowywane 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."),
)

W systemie wieloagentowym możesz też połączyć modele w chmurze i na urządzeniu: użyj Gemini w chmurze jako głównego koordynatora i GenaiPrompt na urządzeniu jako subagentów, którzy obsługują zadania wymagające ochrony prywatności. Więcej informacji o tym wzorcu znajdziesz w poście na blogu dotyczącym ADK na Kotlina i Androida.

Pełną działającą aktywność i więcej przykładów znajdziesz w przykładach ADK w języku Kotlin w GitHubie.