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 compilar agentes rápidamente y escalar verticalmente a aplicaciones complejas de varios agentes.
La biblioteca del ADK para Android proporciona dependencias especializadas y compatibilidad con el tiempo de ejecución diseñadas para entornos móviles. Puedes compilar 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 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 las apps para Android. El código del agente que escribes es idéntico al de la guía de primeros pasos del ADK en Kotlin. Las diferencias son la dependencia de Gradle, la configuración del proyecto y la forma en que invocas el 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 de 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 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
}
}
}
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 integrados en el dispositivo y en la nube 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 agentes secundarios que controlan tareas sensibles a la privacidad.
Para ver una Activity en funcionamiento completa y más ejemplos, consulta los ejemplos de ADK en Kotlin en GitHub.