कैसे करें

स्मार्ट Android ऐप्लिकेशन बनाएं: ऐप्लिकेशन में एजेंटिक वर्कफ़्लो

पढ़ने में लगने वाला समय: 9 मिनट
योलांडा फेरहूफ़ की प्रोफ़ाइल देखें
Jolanda Verhoef डेवलपर रिलेशंस इंजीनियर

"इंटेलिजेंट Android ऐप्लिकेशन बनाएं" ब्लॉग पोस्ट सीरीज़ में आपका फिर से स्वागत है. इसमें आपको किसी बेसिक Android ऐप्लिकेशन को, उपयोगकर्ता की दिलचस्पी के हिसाब से, इंटेलिजेंट, और एजेंटिक अनुभव देने वाले ऐप्लिकेशन में बदलने का तरीका बताया जाता है. हमारी पिछली पोस्ट में, आपने AppFunctions का इस्तेमाल करके इंटेलिजेंस सिस्टम से कनेक्ट करने का तरीका सीखा.

इस पोस्ट में, क्लाउड में चलने वाले, अपने-आप काम करने वाले इन-ऐप्लिकेशन एजेंटिक वर्कफ़्लो बनाने का तरीका बताया गया है.

कभी-कभी कोई टास्क इतना जटिल होता है कि उसे एक ही डिवाइस सेशन में पूरा नहीं किया जा सकता. उदाहरण के लिए, छुट्टियों के लिए यात्रा की पूरी योजना बुक करने में, फ़्लाइट के समय को मैनेज करना, होटल के कमरे चुनना, म्यूज़ियम के टिकट बुक करना, और रेस्टोरेंट के रिज़र्वेशन की योजना बनाना शामिल है. अगर इस प्रोसेस को सीधे किसी फ़ोन या टैबलेट पर चलाया जाता है, तो हो सकता है कि ऐप्लिकेशन बंद हो जाए और आपकी प्रोग्रेस मिट जाए. फ़ोन पर इन सभी चरणों और एपीआई क्रेडेंशियल को मैनेज करना भी मुश्किल हो जाता है.

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

क्लाउड पर होस्ट किए गए एजेंटिक बैकएंड का इस्तेमाल करने के कुछ फ़ायदे हैं:

  • बैकग्राउंड में काम करना: बुकिंग एजेंट, क्लाउड में अपने-आप काम करते हैं. इसलिए, अगर मोबाइल ऐप्लिकेशन बैकग्राउंड में चला जाता है या इंटरनेट कनेक्शन बंद हो जाता है, तो भी बुकिंग की प्रोसेस नहीं रुकती.
  • एक से ज़्यादा एजेंट के बीच जटिल टास्क को मैनेज करना: कोऑर्डिनेटर एजेंट, बुकिंग की ज़िम्मेदारी खास तौर पर बनाए गए सब-एजेंट को सौंप सकता है. साथ ही, उनके बीच की डिपेंडेंसी को मैनेज कर सकता है.
  • क्लाइंट-एग्नोस्टिक यूज़र इंटरफ़ेस (यूआई) रेंडरिंग: बैकएंड, इंटरफ़ेस के स्ट्रक्चर के बारे में डाइनैमिक तौर पर बताता है. इससे आपको क्लाइंट का नया वर्शन रिलीज़ किए बिना, यूज़र इंटरफ़ेस (यूआई) लेआउट को अपडेट करने की सुविधा मिलती है.
booking-assistant.png
बुकिंग असिस्टेंट, बुकिंग की पूरी प्रोग्रेस दिखाता है. इसे इवेंट टाइप के हिसाब से व्यवस्थित किया जाता है.

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

ADK एजेंट की मदद से मुश्किल वर्कफ़्लो को आसान बनाना

कस्टम REST एंडपॉइंट या जटिल वेब सॉकेट का इस्तेमाल करके, मैन्युअल तरीके से ऑर्केस्ट्रेशन फ़्लो को मैनेज करने के बजाय, Agent Development Kit (ADK) का इस्तेमाल किया जा सकता है. एडीके की मदद से, एजेंट तय किए जा सकते हैं और उन्हें Python फ़ंक्शन टूल से लैस किया जा सकता है. इससे डेटाबेस से क्वेरी की जा सकती है और बुकिंग की जा सकती है.

diagram.png
Android ऐप्लिकेशन, मौजूदा यात्रा की योजना का डेटा सर्वर को भेजता है. कोऑर्डिनेटर एजेंट यह चुनता है कि किन सब-एजेंट को ट्रिगर करना है. हर सब-एजेंट अपने नतीजे, शेयर की गई सेशन सूची में भेजता है. यह सूची, नतीजों को Android ऐप्लिकेशन पर वापस स्ट्रीम करती है.

यहां एक आसान एजेंट को तय करने और उसे ADK का इस्तेमाल करके चलाने का तरीका बताया गया है:

# server/main.py

# Note: ADK supports many different coding languages. For now, we use the Python version as it includes support for A2UI which we'll use later in this blog post.

from google.adk import Agent
from google.adk.runners import InMemoryRunner
from google.adk.tools import FunctionTool

# Define custom tools to interact with database
def search_flights(destination: str, date: str) -> list[str]:
    # In production, here you would query our flight database and return dynamic results
    return ["10:00 AM", "2:00 PM"]

def reserve_flight(flight_time: str) -> str:
    # In production, here you would save the reservation transaction
    return "Reserved flight at " + flight_time

# Instantiate the booking agent with specialized tools
flight_agent = Agent(
    name="Flight Booker",
    model="gemini-3.1-flash-lite",
    instruction="Help the user search for flights and book a reservation.",
    tools=[
        FunctionTool(search_flights),
        FunctionTool(reserve_flight, require_confirmation=True)
    ]
)

# Run the agent in memory using a session ID
runner = InMemoryRunner(flight_agent)
async for event in runner.run_async(user_id=user_id, session_id=session_id):
    if event.content:
        print("Agent said:", event.content)

इस सेटअप का इस्तेमाल करके एजेंट को चलाने पर, ADK आपके लिए उसे चलाने के चरणों को मैनेज करता है. यह बातचीत के कॉन्टेक्स्ट को अपने-आप ट्रैक करता है. साथ ही, उपयोगकर्ता और मॉडल के बीच मैसेज को रूट करता है. इसके अलावा, मॉडल के अनुरोध करने पर, रजिस्टर किए गए टूल को एक्ज़ीक्यूट करता है. इससे आपको साफ़-सुथरा प्रोसीजरल लॉजिक लिखने पर फ़ोकस करने में मदद मिलती है. वहीं, फ़्रेमवर्क बैकग्राउंड में ऑर्केस्ट्रेशन को मैनेज करता है.

web_debug.png


इस बैकएंड एजेंट को हमारे Jetpacker ऐप्लिकेशन से कनेक्ट करने के लिए, सर्वर को डिवाइस पर रीयल टाइम में अपडेट स्ट्रीम करने का तरीका चाहिए. इसे AG-UI प्रोटोकॉल का इस्तेमाल करके मैनेज किया जाता है. एजेंट को फ़ोन पर, इंटरैक्टिव कॉम्पोनेंट (जैसे, विकल्प चुनने वाले टूल और सीटिंग ग्रिड) के बारे में बताने और उन्हें डाइनैमिक तौर पर अपडेट करने के लिए, एक स्ट्रक्चर्ड तरीके की भी ज़रूरत होती है. इसके लिए, A2UI प्रोटोकॉल का इस्तेमाल किया जाता है.

AG-UI की मदद से, एजेंट और क्लाइंट के बीच कम्यूनिकेशन को स्टैंडर्ड बनाना

क्लाउड में एजेंट चलाने और Android पर यूज़र इंटरफ़ेस (यूआई) रेंडर करने के लिए, एक स्टैंडर्ड कम्यूनिकेशन चैनल की ज़रूरत होती है. इसके लिए, आपको AG-UI प्रोटोकॉल का इस्तेमाल करना होगा.

एजी-यूआई, दोनों तरफ़ से काम करने वाला ट्रांसपोर्ट लेयर प्रोटोकॉल है. यह एजेंट और यूज़र इंटरफ़ेस (यूआई) क्लाइंट के बीच, मैसेज के टाइप को स्टैंडर्ड बनाता है. एजेंट, क्लाइंट को लाइफ़साइकल इवेंट, टेक्स्ट मैसेज, टूल कॉल, और स्टेट मैनेजमेंट के बारे में जानकारी दे सकता है. इसके बाद, क्लाइंट, एजेंट को उपयोगकर्ता के टेक्स्ट मैसेज, टूल कॉल के नतीजे, और कस्टम ऐक्शन इवेंट वापस भेज सकता है.

सर्वर साइड पर, यह स्टैंडर्ड सर्वर-सेंट इवेंट के तौर पर फ़ॉर्मैट किए गए अपडेट दिखाता है. जैसे, JSON डेल्टा वाला event: TEXT_MESSAGE_CONTENT. Android पर, Kotlin SDK इस स्ट्रीम को सुनता है और पेलोड को टाइप-सेफ़ क्लाइंट इवेंट पर अपने-आप मैप करता है:

// BookingAssistantViewModel.kt

import com.agui.client.agent.HttpAgent
import com.agui.client.agent.HttpAgentConfig
import com.agui.core.types.RunAgentInput
import com.agui.core.types.UserMessage
import com.agui.core.types.TextMessageStartEvent
import com.agui.core.types.TextMessageContentEvent
import com.agui.core.types.TextMessageEndEvent

val config = HttpAgentConfig(
    agentId = "booking-assistant",
    threadId = threadId,
    url = "https://<your-backend-url>"
)
val agent = HttpAgent(config, httpClient)

// Set up the input with the session thread and user instruction
val input = RunAgentInput(
    threadId = threadId,
    runId = runId,
    messages = listOf(UserMessage("Book a flight to Paris"))
)

// Run the agent flow and collect lifecycle events
agent.runAgentObservable(input)
    .collect { event ->
        when (event) {
            is TextMessageStartEvent -> { /* ... */ }
            is TextMessageContentEvent -> { /* ... */ }
            is TextMessageEndEvent -> {
                // Handle the completed message
            }
        }
    }

इसके बाद, स्टैंडर्ड AG-UI इवेंट के इन अलग-अलग टाइप को रेंडर करने के लिए, यूज़र इंटरफ़ेस (यूआई) लिखा जा सकता है. इससे आपको "चैटबॉट" का अनुभव मिलेगा:

manage_bookings.png
एक बेसिक इंटरफ़ेस, जिसकी मदद से उपयोगकर्ता किसी असिस्टेंट के साथ चैट कर सकता है.

A2UI के साथ, एजेंट को यूज़र इंटरफ़ेस (यूआई) के बारे में बताने की सुविधा

पारंपरिक चैटबॉट आम तौर पर, सादा टेक्स्ट या कस्टम JSON पेलोड दिखाते हैं. जटिल इंटरफ़ेस बनाते समय, क्लाइंट ऐप्लिकेशन को इन पेलोड को पार्स करना होता है. साथ ही, उन्हें पहले से बनी खास स्क्रीन पर मैप करना होता है. इससे एक डिपेंडेंसी बनती है: जब भी कोई नई सुविधा जोड़ी जाती है, लेआउट बदला जाता है या उपयोगकर्ता के नए इंटरैक्शन के लिए सहायता दी जाती है, तो आपको बैकएंड एजेंट और मोबाइल ऐप्लिकेशन, दोनों को अपडेट करना पड़ता है. इसके लिए, ऐप्लिकेशन का अपडेट पब्लिश करना होगा और उपयोगकर्ताओं के इसे इंस्टॉल करने का इंतज़ार करना होगा.

इस समस्या को हल करने के लिए, A2UI प्रोटोकॉल का इस्तेमाल करें. A2UI की मदद से, एजेंट यूज़र इंटरफ़ेस (यूआई) के कॉम्पोनेंट के बारे में बता सकते हैं, ताकि उन्हें क्लाइंट पर डाइनैमिक तौर पर रेंडर किया जा सके. क्लाइंट ऐप्लिकेशन, उन कॉम्पोनेंट का कैटलॉग तय करता है जो वह इस्तेमाल करता है. इसके बाद, सर्वर एक JSON पेलोड भेजता है, जिसमें कॉम्पोनेंट के लेआउट और प्रॉपर्टी की जानकारी होती है:

{
  "version": "v0.9",
  "updateComponents": {
    "surfaceId": "Flight Reservation",
    "components": [
      {
        "id": "flight_option_picker",
        "component": "InteractiveOptionPicker",
        "properties": {
          "prompt": "Select a flight time:",
          "options": [
            "10:00 AM",
            "2:00 PM"
          ],
          "selectedIdx": null,
          "confirmBtnText": "Confirm Flight"
        }
      }
    ]
  }
}

सर्वर यह तय करता है कि कैटलॉग के कौनसे कॉम्पोनेंट रेंडर करने हैं. साथ ही, उनकी चालू प्रॉपर्टी वैल्यू भी तय करता है. इससे क्लाइंट के विज़ुअल लागू करने की जानकारी, एजेंट के वर्कफ़्लो की स्थिति से अलग हो जाती है.

बैकएंड यूज़र इंटरफ़ेस (यूआई) स्कीमा डिज़ाइन करना

एजेंट को इन JSON पेलोड को सही तरीके से जनरेट करने के लिए, यह जानना ज़रूरी है कि कौनसे कॉम्पोनेंट उपलब्ध हैं और वे किन प्रॉपर्टी को स्वीकार करते हैं.

इसके लिए, ADK A2UI इंटिग्रेशन का इस्तेमाल करें. हमारे कैटलॉग में मौजूद हर कॉम्पोनेंट के लिए, मैन्युअल तरीके से प्रॉम्प्ट के निर्देश लिखने के बजाय, A2uiSchemaManager उनके JSON स्कीमा और लेआउट के निर्देशों को सीधे सिस्टम प्रॉम्प्ट में कंपाइल करता है. इससे यह पक्का होता है कि मॉडल, मान्य A2UI पेलोड जनरेट करने के लिए, सही स्ट्रक्चर और फ़ॉर्मैटिंग के नियमों को सीखे:

# server/main.py

from a2ui.schema.manager import A2uiSchemaManager
from a2ui.schema.constants import VERSION_0_9
from a2ui.schema.catalog import CatalogConfig
from a2ui.basic_catalog.provider import BasicCatalog

# Initialize A2UI Schema Manager with custom booking component catalog
schema_manager = A2uiSchemaManager(
    version=VERSION_0_9,
    catalogs=[
        BasicCatalog.get_config(version=VERSION_0_9),
        CatalogConfig.from_path(
            name="https://example.com/catalogs/booking_assistant/v1/catalog.json",
            catalog_path="booking_catalog.json"
        )
    ]
)

# Compile prompt instructions including the A2UI JSON schema
A2UI_SYSTEM_INSTRUCTION = schema_manager.generate_system_prompt(
    role_description="You are a helpful travel booking assistant.",
    ui_description="Use InteractiveOptionPicker for choices, SeatSelectionPicker for seat selection...",
    include_schema=True,
    include_examples=True,
    allowed_components=["InteractiveOptionPicker", "SeatSelectionPicker", "BookingStatus"]
)

जनरेट किए गए इस सिस्टम निर्देश की मदद से, एलएलएम को स्कीमा लेआउट में शामिल किया जाता है. साथ ही, उसे कॉम्पोनेंट के अपडेट तैयार करने का सटीक तरीका पता होता है. इन अपडेट को Android क्लाइंट रेंडर कर सकता है.

Jetpack Compose की मदद से, A2UI को नेटिव तौर पर रेंडर करना

Android पर इन कॉम्पोनेंट ट्री को नेटिव तौर पर रेंडर करने के लिए, Jetpack Compose A2UI रेंडरर की नई लाइब्रेरी का इस्तेमाल करें.

सबसे पहले, हमारे मॉड्यूल की build.gradle.kts फ़ाइल में डिपेंडेंसी जोड़ें:

// android/feature/trip/booking_assistant/build.gradle.kts
dependencies {
    implementation("androidx.a2ui:a2ui-model:1.0.0-alpha01")
    implementation("androidx.a2ui.compose:compose-runtime:1.0.0-alpha01")
    implementation("androidx.a2ui.compose:compose-ui:1.0.0-alpha01")
    implementation("androidx.compose.material3:material3-a2ui:1.0.0-alpha01")
}

कैटलॉग में मौजूद हर कॉम्पोनेंट क्लास (जैसे, BookingStatusComponent) यह तय करती है कि JSON पेलोड से मिली प्रॉपर्टी को Jetpack Compose के कंपोज़ेबल फ़ंक्शन में कैसे मैप किया जाए.

कैटलॉग में कस्टम कॉम्पोनेंट रजिस्टर करें:

// CustomBookingAssistantCatalog.kt

import androidx.a2ui.compose.ui.A2uiCatalog

fun bookingAssistantCatalog(): A2uiCatalog {
    return A2uiCatalog(
        catalogId = "https://example.com/catalogs/booking_assistant/v1/catalog.json",
        components = listOf(
            InteractiveOptionPickerComponent(),
            SeatSelectionPickerComponent(),
            BookingStatusComponent()
        )
    )
}

सलाह: Jetpacker, बुकिंग फ़्लो के लिए बनाए गए कस्टम कॉम्पोनेंट (InteractiveOptionPicker, SeatSelectionPicker, BookingStatus) लागू करता है. अगर आपका एजेंट टेक्स्ट, कार्ड, बटन, लाइन, कॉलम, चेकबॉक्स, और तारीख-समय चुनने वाले टूल जैसे स्टैंडर्ड एलिमेंट का इस्तेमाल करता है, तो material3-a2ui आपको materialA2uiBasicCatalogV1(...) भी उपलब्ध कराता है. इससे आपको इस्तेमाल के लिए तैयार Material 3 कॉम्पोनेंट मिलते हैं. इसके लिए, आपको कोई कस्टम कॉम्पोनेंट लिखने की ज़रूरत नहीं पड़ती.

ध्यान दें: बैकएंड और मोबाइल क्लाइंट को अलाइन रखने के लिए, दोनों एक ही कैटलॉग डेफ़िनिशन आईडी (https://example.com/catalogs/booking_assistant/v1/catalog.json) का इस्तेमाल करते हैं. अगर बैकएंड कैटलॉग में प्रॉपर्टी जोड़ी जाती हैं या उनमें बदलाव किया जाता है, तो आपको वर्शन नंबर बढ़ाना होगा. साथ ही, पार्स करने से जुड़ी गड़बड़ियों को रोकने के लिए, मैच होने वाली Kotlin कॉम्पोनेंट क्लास को अपडेट करना होगा.

BookingAssistantViewModel में, A2uiMessageProcessor का इस्तेमाल करके A2UI मैसेज प्रोसेस करें और हमारे ऐक्टिव प्लैटफ़ॉर्म अपडेट करें:

// BookingAssistantViewModel.kt
import androidx.lifecycle.ViewModel
import androidx.a2ui.model.processor.A2uiSurfaceModel
import androidx.a2ui.compose.ui.A2uiMessageProcessor
import kotlinx.coroutines.flow.StateFlow

class BookingAssistantViewModel : ViewModel() {
    private val messageProcessor = A2uiMessageProcessor(
        catalogs = listOf(bookingAssistantCatalog())
    )
    val activeSurfaces: StateFlow<List<A2uiSurfaceModel>> = messageProcessor.activeSurfaces
    
    init {
        viewModelScope.launch(Dispatchers.Default) { processor.collectMessages() }
    }

    // ...
}

Compose स्क्रीन पर, इन सरफ़ेस को इकट्ठा करें और androidx.compose.material3:material3-a2ui के आधिकारिक A2uiSurface कंपोज़ेबल का इस्तेमाल करके, हर एक को रेंडर करें. A2uiSurface, रिएक्टिव कॉम्पोनेंट की स्थिति पर नज़र रखने, Material 3 के लोडिंग इंडिकेटर, गड़बड़ी के फ़ॉलबैक, और अपडेट के बीच ऐनिमेटेड ट्रांज़िशन को अपने-आप मैनेज करता है:

// BookingAssistantScreen.kt
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.a2ui.A2uiSurface

@Composable
fun BookingAssistantScreen(
    viewModel: BookingAssistantViewModel,
    modifier: Modifier = Modifier
) {
    val activeSurfaces by viewModel.activeSurfaces.collectAsState()
    LazyColumn(
        modifier = modifier.fillMaxWidth(),
        verticalArrangement = Arrangement.spacedBy(16.dp)
    ) {
        items(activeSurfaces) { surfaceModel ->
            Card(modifier = Modifier.fillMaxWidth()) {
                A2uiSurface(
                    surfaceModel = surfaceModel,
                    modifier = Modifier.fillMaxWidth().wrapContentHeight()
                )
            }
        }
    }
}

अब आपको बैकएंड में चल रहे हमारे एजेंट से जनरेट किए गए कई यूज़र इंटरफ़ेस (यूआई) दिखेंगे:

booking-assistant.png
बुकिंग में मदद करने वाला एक बेहतरीन असिस्टेंट, जो उपयोगकर्ता से इंटरैक्ट करने के लिए टेक्स्ट के बजाय यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल करता है.

पूरी जानकारी को एक जगह इकट्ठा किया जा रहा है

एजेंट के वर्कफ़्लो को क्लाउड में होस्ट करके और AG-UI और A2UI प्रोटोकॉल का एक साथ इस्तेमाल करके, हम डाइनैमिक और नेटिव Android इंटरफ़ेस बना सकते हैं. ये इंटरफ़ेस सीधे एआई मॉडल से मैनेज किए जाते हैं. AG-UI, मैसेज और लाइफ़साइकल इवेंट के लिए रीयल-टाइम में दोनों तरफ़ से स्ट्रीमिंग चैनल बनाता है. वहीं, A2UI की मदद से क्लाउड एजेंट, इंटरैक्टिव यूआई कॉम्पोनेंट के बारे में डाइनैमिक तरीके से जानकारी दे सकता है. इससे क्लाइंट ऐप्लिकेशन, सिलसिलेवार तरीके से बैकएंड ऑर्केस्ट्रेशन लॉजिक से पूरी तरह अलग रहता है.

GitHub पर Jetpacker के लिए पूरा सोर्स कोड देखें. साथ ही, Google के एआई की मदद से इंटेलिजेंट Android ऐप्लिकेशन बनाएं वीडियो देखें. इससे आपको अपने ऐप्लिकेशन में एजेंटिक वर्कफ़्लो को सीधे इंटिग्रेट करने के तरीके के बारे में ज़्यादा जानकारी मिलेगी.

इस ब्लॉग पोस्ट सीरीज़ के अन्य हिस्से देखें:
▪️ पहला हिस्सा: ऐप्लिकेशन के बारे में जानकारी और खास जानकारी.
📱 दूसरा हिस्सा: उपयोगकर्ता के डिवाइस पर मौजूद इंटेलिजेंस. ML Kit के जेन एआई एपीआई और Gemini Nano के बारे में ज़्यादा जानें. इनकी मदद से, निजता को प्राथमिकता देने वाली सुविधाएं बनाई जा सकती हैं. जैसे, यात्रा की योजना की खास जानकारी पाना, रसीद को पार्स करना, और डिवाइस पर ऑडियो प्रोसेस करना.
☁️ तीसरा हिस्सा: हाइब्रिड और क्लाउड रीज़निंग. जानें कि Firebase AI Logic का इस्तेमाल करके, एलएलएम से मिले जवाबों को Google Maps और वेब कॉन्टेक्स्ट जैसे रीयल-वर्ल्ड डेटा के साथ कैसे जोड़ा जा सकता है.
⚙️ चौथा पार्ट: सिस्टम इंटिग्रेशन. AppFunctions का इस्तेमाल करके, Android इंटेलिजेंस सिस्टम के साथ इंटिग्रेट करना.
🤖 पांचवां हिस्सा (यह पोस्ट!): ऐप्लिकेशन में एजेंटिक वर्कफ़्लो. A2UI और ADK की मदद से, बुकिंग की पूरी प्रोसेस में मदद करने वाले असिस्टेंट जोड़कर, ऐप्लिकेशन को बेहतर बनाएं.

क्या आपको Android डेवलपमेंट के बारे में ज़्यादा जानना है? Android Developers को YouTube या LinkedIn पर फ़ॉलो करें!

इस ब्लॉग पोस्ट के सभी कोड स्निपेट, कॉपीराइट की इस सूचना का पालन करते हैं:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0
लेखक:
पढ़ना जारी रखें