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 compilar agentes basados en 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 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.
Usa ADK Kotlin en proyectos de Android
Puedes usar la API de agente de ADK Kotlin para compilar agentes de IA que se ejecuten dentro de las apps para Android. El código de agente que escribes es idéntico a la guía de introducción de ADK 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 superior, minSdk 24 o superior)
Configura tu proyecto de Android
En el archivo build.gradle.kts de tu proyecto de Android, agrega la dependencia de ADK Android y el procesador de anotaciones 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 ADK Kotlin. 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 tecnología 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 y mantengan 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 de la nube y modelos integrados en el dispositivo en un sistema multiagente: usa un Gemini basado en la nube para el orquestador 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 blog post.
Para obtener una actividad de trabajo completa y más ejemplos, consulta los ejemplos de ADK Kotlin en GitHub.