Biblioteka pakiet 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 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ć agenty 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 API możesz tworzyć agentów, którzy 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ć agentów AI, którzy działają w aplikacjach na Androida. Kod agenta, który napiszesz, jest identyczny z kodem w przewodniku Pierwsze kroki dotyczącym pakietu ADK 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 następujące 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 krótkim wprowadzeniu do pakietu ADK w języku Kotlin. Przykładowy kodHelloTimeAgent z syntaksą @Tool, @Param i .generatedTools() działa na Androidzie bez modyfikacji:
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 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
}
}
}
Używanie agentów do generowania interfejsu
Jeśli agent musi zwracać strukturalne, interaktywne interfejsy użytkownika, takie jak karty, formularze lub listy, zamiast zwykłego tekstu, użyj protokołu agent-to-UI (A2UI).
Możesz użyć renderera A2UI Jetpack Compose, aby automatycznie renderować odpowiedzi A2UI jako natywne komponenty Jetpack Compose i Material 3 w hierarchii interfejsu aplikacji. Na początek zapoznaj się z przewodnikiem po A2UI w Jetpack Compose.
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 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."),
)
W systemie wieloagentowym możesz też połączyć modele w chmurze i na urządzeniu: użyj modelu Gemini w chmurze jako głównego koordynatora i modeli 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.
Kompletną działającą aktywność i więcej przykładów znajdziesz w przykładach ADK w Kotlinie w GitHubie.