La bibliothèque Agent Development Kit (ADK) pour Android vous permet de créer et d'intégrer des agents IA sophistiqués directement dans vos applications Android. ADK est un framework de développement Open Source permettant de créer des agents basés sur l'IA qui s'exécutent localement, sur des services hébergés et sur des appareils mobiles Android. Le framework est compatible avec les langages de programmation Kotlin et Java, ce qui vous permet de commencer rapidement à créer des agents et de passer à des applications complexes multi-agents.
La bibliothèque ADK pour Android fournit des dépendances spécialisées et une prise en charge de l'exécution adaptées aux environnements mobiles. Vous pouvez créer des agents qui exécutent des modèles d'IA sur l'appareil à l'aide de Gemini Nano et des API ML Kit GenAI. Vous pouvez ainsi créer des expériences d'IA axées sur la confidentialité et à faible latence qui peuvent fonctionner sans accès au réseau.
Utiliser ADK Kotlin dans des projets Android
Vous pouvez utiliser l'API d'agent ADK Kotlin pour créer des agents IA qui s'exécutent dans des applications Android. Le code d'agent que vous écrivez est identique à celui du guide de démarrage d'ADK Kotlin Get started. Les différences concernent la dépendance Gradle, la configuration du projet et la façon dont vous appelez l'agent au moment de l'exécution.
Prérequis
La bibliothèque ADK pour Android présente les exigences de développement suivantes :
- Android Studio
- SDK Android (compileSdk 34 ou version ultérieure, minSdk 24 ou version ultérieure)
Configurer votre projet Android
Dans le fichier build.gradle.kts de votre projet Android, ajoutez la dépendance ADK Android et le processeur d'annotations 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)
}
Définissez votre agent
Le code de l'agent est identique au démarrage rapide d'ADK Kotlin. L'exemple de code HelloTimeAgent avec la syntaxe @Tool, @Param et .generatedTools() fonctionne sans modification sur Android :
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(),
)
}
Exécuter l'agent à partir de votre application Android
Sur les appareils Android, utilisez InMemoryRunner pour appeler l'agent et collecter les réponses d'une coroutine, comme illustré dans l'exemple de code suivant :
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
}
}
}
Modèles sur l'appareil avec Gemini Nano
L'artefact ADK pour Android inclut la prise en charge de l'inférence sur l'appareil à l'aide de Gemini Nano via l'API ML Kit GenAI. Cette approche permet aux agents de s'exécuter sans accès au réseau, en conservant les données sur l'appareil.
Pour utiliser un modèle sur l'appareil, créez un modèle GenaiPrompt au lieu de Gemini, comme illustré dans l'exemple de code suivant :
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."),
)
Vous pouvez également combiner des modèles cloud et sur l'appareil dans un système multi-agents : utilisez un modèle Gemini basé sur le cloud pour l'orchestrateur racine et des modèles GenaiPrompt sur l'appareil pour les sous-agents qui gèrent les tâches sensibles à la confidentialité.
Pour obtenir une activité de travail complète et d'autres exemples, consultez les exemples ADK Kotlin sur GitHub.