Criar agentes do ADK para Android

A biblioteca do Kit de Desenvolvimento de Agente (ADK) para Android permite criar e integrar agentes de IA sofisticados diretamente nos seus apps Android. O ADK é um framework de desenvolvedores de código aberto para criar agentes com tecnologia de IA que são executados localmente, em serviços hospedados e em dispositivos móveis Android. O framework é compatível com as linguagens de programação Kotlin e Java, permitindo que você comece a criar agentes rapidamente e escalone verticalmente para aplicativos multiagente complexos.

A biblioteca do ADK para Android oferece dependências especializadas e suporte de tempo de execução adaptado para ambientes móveis. É possível criar agentes que executam modelos de IA no dispositivo usando o Gemini Nano com as APIs GenAI do Kit de ML. Assim, você cria experiências de IA com foco na privacidade e baixa latência que podem funcionar sem acesso à rede.

Usar o ADK Kotlin em projetos Android

Use a API do agente Kotlin do ADK para criar agentes de IA que são executados em apps Android. O código do agente que você escreve é idêntico ao guia Começar do ADK Kotlin. As diferenças são a dependência do Gradle, a configuração do projeto e como você invoca o agente no tempo de execução.

Pré-requisitos

A biblioteca ADK para Android tem os seguintes requisitos de desenvolvimento:

• Android Studio
• SDK do Android (compileSdk 34 ou mais recente, minSdk 24 ou mais recente)

Configurar seu projeto do Android

No build.gradle.kts do projeto Android, adicione a dependência do ADK Android e o processador de anotações do 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)
}

Importante: essa configuração de dependência substitui a dependência da JVM. Projetos Android usam google-adk-kotlin-core-android em vez de google-adk-kotlin-core. Não adicione os dois. O artefato do Android inclui a API do agente do ADK completa, além da compatibilidade com modelos específicos do Android.

definir seu agente

O código do agente é idêntico ao Guia de início rápido do Kotlin do ADK. O exemplo de código HelloTimeAgent com a sintaxe @Tool, @Param e .generatedTools() funciona sem modificação no 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(),
    )
}

Aviso: não incorpore chaves de API em apps cliente nem inclua sua chave de API em um aplicativo publicado. Para casos de uso de produção, chame modelos de nuvem pelo seu próprio serviço de back-end ou pelo Firebase AI Logic para que as chaves de API nunca sejam expostas no código do cliente.

Executar o agente no app Android

Em dispositivos Android, use InMemoryRunner para invocar o agente e coletar respostas de uma corrotina, conforme mostrado no exemplo de código a seguir:

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 no dispositivo com o Gemini Nano

O artefato do ADK para Android inclui suporte à inferência no dispositivo usando o Gemini Nano pela API GenAI do Kit de ML. Essa abordagem permite que os agentes sejam executados sem acesso à rede, mantendo os dados no dispositivo.

Para usar um modelo no dispositivo, crie um modelo GenaiPrompt em vez de Gemini, conforme mostrado no exemplo de código a seguir:

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

Também é possível combinar modelos na nuvem e no dispositivo em um sistema multiagente: use um Gemini baseado na nuvem para o orquestrador raiz e modelos GenaiPrompt no dispositivo para subagentes que lidam com tarefas sensíveis à privacidade.

Para ver uma atividade completa e mais exemplos, consulte os exemplos do ADK Kotlin no GitHub.