Crea agentes del ADK para Android

La biblioteca del Kit de desarrollo de agentes (ADK) para Android te permite crear e integrar agentes de IA sofisticados directamente en tus apps para Android. El ADK es un framework de código abierto para desarrolladores que permite crear agentes potenciados por IA que se ejecutan de forma local, en servicios alojados y en dispositivos móviles Android. El framework admite los lenguajes de programación Kotlin y Java, lo que te permite comenzar a crear agentes con rapidez y escalar a aplicaciones complejas de varios agentes.

La biblioteca de ADK para Android proporciona dependencias especializadas y compatibilidad con el entorno de ejecución adaptada a los entornos móviles. Puedes crear agentes que ejecuten modelos de IA integrados en el dispositivo con Gemini Nano a través de las APIs de IA generativa de ML Kit, lo que te permite crear experiencias de IA centradas en la privacidad y de baja latencia que pueden funcionar sin acceso a la red.

Usa ADK Kotlin en proyectos de Android

Puedes usar la API de agentes de Kotlin del ADK para compilar agentes de IA que se ejecuten dentro de apps para Android. El código del agente que escribes es idéntico al de la guía de introducción de ADK Kotlin. Las diferencias son la dependencia de Gradle, la configuración del proyecto y cómo invocas el agente en el entorno de ejecución.

Requisitos previos

La biblioteca de ADK para Android tiene los siguientes requisitos de desarrollo:

  • Android Studio
  • SDK de Android (compileSdk 34 o posterior, minSdk 24 o posterior)

Configura tu proyecto de Android

En el archivo build.gradle.kts de tu proyecto de Android, agrega la dependencia de ADK para Android y el procesador de anotaciones de 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)
}

Define tu agente

El código del agente es idéntico a la guía de inicio rápido de Kotlin del ADK. El ejemplo de código HelloTimeAgent con la sintaxis @Tool, @Param y .generatedTools() funciona sin modificaciones en 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(),
    )
}

Ejecuta el agente desde tu app para Android

En los dispositivos con Android, usa InMemoryRunner para invocar al agente y recopilar respuestas de una corrutina, como se muestra en el siguiente ejemplo de código:

// 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
        }
    }
}

Usa agentes para generar la IU

Cuando tu agente necesite devolver interfaces de usuario interactivas y estructuradas, como tarjetas, formularios o listas, en lugar de texto sin formato, usa el protocolo agent-to-UI (A2UI).

Puedes usar el renderizador de A2UI de Jetpack Compose para renderizar automáticamente las respuestas de A2UI como componentes nativos de Jetpack Compose y Material 3 en la jerarquía de la IU de tu app. Para comenzar, consulta la guía de A2UI de Jetpack Compose.

Modelos integrados en el dispositivo con Gemini Nano

El artefacto del ADK para Android incluye compatibilidad con la inferencia integrada en el dispositivo con Gemini Nano a través de la API de IA generativa de ML Kit. Este enfoque permite que los agentes se ejecuten sin acceso a la red, lo que mantiene los datos en el dispositivo.

Para usar un modelo integrado en el dispositivo, crea un modelo GenaiPrompt en lugar de Gemini, como se muestra en el siguiente ejemplo de código:

// 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."),
)

También puedes combinar modelos de la nube y modelos integrados en el dispositivo en un sistema multiagente: usa un Gemini basado en la nube para el organizador raíz y modelos GenaiPrompt integrados en el dispositivo para los subagentes que controlan tareas sensibles a la privacidad. Para obtener más información sobre este patrón, consulta la entrada de blog del ADK para Kotlin y Android.

Para ver una actividad completa en funcionamiento y más ejemplos, consulta los ejemplos de ADK en Kotlin en GitHub.