La biblioteca del Kit de desarrollo de agentes (ADK) para Android te permite compilar 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 rápidamente y escalar verticalmente a aplicaciones complejas de varios agentes.
La biblioteca del ADK para Android proporciona dependencias especializadas y asistencia en tiempo de ejecución diseñadas para entornos móviles. Puedes crear agentes que ejecuten modelos de IA integrados en el dispositivo con Gemini Nano usando las APIs de IA generativa de ML Kit, lo que te permite crear experiencias de IA enfocadas en la privacidad y de baja latencia que pueden funcionar sin acceso a la red.
Cómo usar ADK Kotlin en proyectos de Android
Puedes usar la API del agente 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 primeros pasos del ADK de Kotlin. Las diferencias son la dependencia de Gradle, la configuración del proyecto y la forma en que invocas al agente en el tiempo de ejecución.
Requisitos previos
La biblioteca del 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 build.gradle.kts de tu proyecto para Android, agrega la dependencia de ADK 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
}
}
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 al de 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 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 agente a IU (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 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.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."),
)
También puedes combinar modelos en 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 Activity en funcionamiento completa y más ejemplos, consulta los ejemplos de ADK en Kotlin en GitHub.