Créer des agents ADK pour Android

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 optimisés par 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 à créer rapidement des agents et de passer à des applications multi-agents complexes.

La bibliothèque ADK pour Android fournit des dépendances spécialisées et une compatibilité d'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 d'IA générative ML Kit. 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 de l'agent que vous écrivez est identique à celui du guide Premiers pas avec l'ADK Kotlin. Les différences résident dans la dépendance Gradle, la configuration du projet et la manière dont vous appelez l'agent au moment de l'exécution.

Prérequis

La bibliothèque ADK pour Android est soumise aux 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 Android ADK 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
    }

    packaging {
        resources {
            excludes += "/META-INF/{INDEX.LIST,DEPENDENCIES}"
        }
    }
}

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 à celui du guide de démarrage rapide Kotlin pour l'ADK. 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 depuis 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
        }
    }
}

Utiliser des agents pour générer une UI

Lorsque votre agent doit renvoyer des interfaces utilisateur structurées et interactives (comme des fiches, des formulaires ou des listes) au lieu de texte brut, utilisez le protocole agent-to-UI (A2UI).

Vous pouvez utiliser le moteur de rendu A2UI Jetpack Compose pour afficher automatiquement les réponses A2UI en tant que composants Jetpack Compose et Material 3 natifs dans la hiérarchie de l'UI de votre application. Pour commencer, consultez le guide Jetpack Compose pour l'A2UI.

Modèles sur l'appareil avec Gemini Nano

L'artefact ADK pour Android est compatible avec l'inférence sur l'appareil à l'aide de Gemini Nano via l'API GenAI de ML Kit. 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.Generation
// import com.google.mlkit.genai.prompt.GenerativeModel
// Create an ML Kit GenerativeModel for on-device inference
val generativeModel: GenerativeModel = Generation.getClient()
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-agent : 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 en termes de confidentialité. Pour en savoir plus sur ce modèle, consultez l'article de blog sur l'ADK pour Kotlin et Android.

Pour obtenir une activité complète et d'autres exemples, consultez les exemples ADK Kotlin sur GitHub.