Android के लिए ADK एजेंट बनाना

Android लाइब्रेरी के लिए Agent Development Kit (ADK) की मदद से, सीधे तौर पर अपने Android ऐप्लिकेशन में बेहतर एआई एजेंट बनाए और उन्हें इंटिग्रेट किए जा सकते हैं. ADK एक ओपन-सोर्स डेवलपर फ़्रेमवर्क है. इसकी मदद से, एआई की मदद से काम करने वाले एजेंट बनाए जा सकते हैं. ये एजेंट, स्थानीय तौर पर, होस्ट की गई सेवाओं पर, और Android मोबाइल डिवाइसों पर काम करते हैं. यह फ़्रेमवर्क, Kotlin और Java प्रोग्रामिंग लैंग्वेज के साथ काम करता है. इससे आपको एजेंट बनाने में मदद मिलती है. साथ ही, एक से ज़्यादा एजेंट वाले मुश्किल ऐप्लिकेशन को स्केल अप करने में भी मदद मिलती है.

Android के लिए ADK लाइब्रेरी, मोबाइल एनवायरमेंट के लिए खास तौर पर तैयार की गई डिपेंडेंसी और रनटाइम सपोर्ट उपलब्ध कराती है. ML Kit GenAI API का इस्तेमाल करके, Gemini Nano की मदद से उपयोगकर्ता के डिवाइस पर एआई मॉडल चलाने वाले एजेंट बनाए जा सकते हैं. इससे, निजता को ध्यान में रखकर और कम इंतज़ार के समय में एआई की सुविधाएँ उपलब्ध कराई जा सकती हैं. ये सुविधाएँ, नेटवर्क ऐक्सेस के बिना भी काम कर सकती हैं.

Android प्रोजेक्ट में ADK Kotlin का इस्तेमाल करना

ADK Kotlin एजेंट एपीआई का इस्तेमाल करके, ऐसे एआई एजेंट बनाए जा सकते हैं जो Android ऐप्लिकेशन में काम करते हैं. आपने जो एजेंट कोड लिखा है वह ADK Kotlin की शुरू करें गाइड में दिए गए कोड जैसा ही है. इनके बीच अंतर, Gradle डिपेंडेंसी, प्रोजेक्ट कॉन्फ़िगरेशन, और रनटाइम के दौरान एजेंट को शुरू करने के तरीके में होता है.

ज़रूरी शर्तें

Android के लिए ADK लाइब्रेरी को डेवलप करने के लिए, ये ज़रूरी शर्तें पूरी करनी होंगी:

• Android Studio
• Android SDK (compileSdk 34 या इसके बाद का वर्शन, minSdk 24 या इसके बाद का वर्शन)

अपने Android प्रोजेक्ट को कॉन्फ़िगर करना

अपने Android प्रोजेक्ट की build.gradle.kts में, ADK Android डिपेंडेंसी और 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)
}

अपने एजेंट के बारे में जानकारी देना

एजेंट कोड, ADK Kotlin Quickstart के जैसा ही है. @Tool, @Param, और .generatedTools() सिंटैक्स के साथ दिया गया HelloTimeAgent कोड का उदाहरण, 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(),
    )
}

अपने Android ऐप्लिकेशन से एजेंट को चलाना

Android डिवाइसों पर, एजेंट को शुरू करने और किसी को-रूटीन से जवाब इकट्ठा करने के लिए, InMemoryRunner का इस्तेमाल करें. इसका उदाहरण यहां दिया गया है:

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

यूज़र इंटरफ़ेस (यूआई) जनरेट करने के लिए एजेंट का इस्तेमाल करना

जब आपके एजेंट को सादे टेक्स्ट के बजाय, स्ट्रक्चर्ड और इंटरैक्टिव यूज़र इंटरफ़ेस (जैसे, कार्ड, फ़ॉर्म या सूचियां) दिखाने हों, तब एजेंट से यूज़र इंटरफ़ेस (ए2यूआई) प्रोटोकॉल का इस्तेमाल करें.

Jetpack Compose A2UI रेंडरर का इस्तेमाल करके, A2UI रिस्पॉन्स को अपने-आप रेंडर किया जा सकता है. इससे, आपके ऐप्लिकेशन की यूज़र इंटरफ़ेस (यूआई) हैरारकी में, A2UI रिस्पॉन्स को नेटिव Jetpack Compose और Material 3 कॉम्पोनेंट के तौर पर रेंडर किया जा सकता है. शुरू करने के लिए, Jetpack Compose A2UI गाइड देखें.

Gemini Nano की सुविधा वाले उपयोगकर्ता के डिवाइस पर मौजूद मॉडल

Android के लिए ADK आर्टफ़ैक्ट में, ML Kit GenAI API के ज़रिए Gemini Nano का इस्तेमाल करके, डिवाइस पर इन्फ़रेंस करने की सुविधा शामिल है. इस तरीके से, एजेंट बिना नेटवर्क ऐक्सेस के काम कर सकते हैं. साथ ही, डेटा को डिवाइस पर सेव रखा जाता है.

उपयोगकर्ता के डिवाइस पर मौजूद मॉडल का इस्तेमाल करने के लिए, Gemini के बजाय GenaiPrompt मॉडल बनाएं. इसके लिए, यहां दिया गया कोड देखें:

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

मल्टी-एजेंट सिस्टम में, क्लाउड और उपयोगकर्ता के डिवाइस पर मौजूद मॉडल को भी साथ में इस्तेमाल किया जा सकता है: रूट ऑर्केस्ट्रेटर के लिए, क्लाउड पर आधारित Gemini का इस्तेमाल करें. साथ ही, निजता से जुड़े टास्क को मैनेज करने वाले सब-एजेंट के लिए, उपयोगकर्ता के डिवाइस पर मौजूद GenaiPrompt मॉडल का इस्तेमाल करें. इस पैटर्न के बारे में ज़्यादा जानने के लिए, Kotlin और Android के लिए ADK की ब्लॉग पोस्ट पढ़ें.

पूरी तरह से काम करने वाली ऐक्टिविटी और ज़्यादा उदाहरणों के लिए, GitHub पर ADK Kotlin के उदाहरण देखें.