Инструкции

Создание умных приложений для Android: агентные рабочие процессы в приложениях

Время на чтение: 9 минут
Посмотреть профиль Иоланды Верхуф
Jolanda Verhoef Developer Relations Engineer

Добро пожаловать в серию публикаций "Создание умных приложений для Android". В ней мы рассказываем, как превратить базовое приложение для Android в персонализированное, умное и агентное. В предыдущей записи мы рассказали, как подключиться к интеллектуальной системе с помощью AppFunctions.

В этой статье вы узнаете, как создавать автономные рабочие процессы на основе агентов в приложении, работающие в облаке.

Иногда задача слишком сложна для одного сеанса на устройстве. Например, чтобы забронировать поездку на отпуск, нужно согласовать время рейсов, выбрать номера в отеле, заказать билеты в музей и зарезервировать столики в ресторанах. Если вы запустите этот многоэтапный процесс непосредственно на мобильном устройстве, приложение может закрыться, и вы потеряете прогресс. Управлять всеми этими шагами и учетными данными API на телефоне также быстро становится сложно.

Для таких длительных многоэтапных рабочих процессов можно использовать собственный сервер. Бэкенд выполняет агентов бронирования в фоновом режиме, а приложение Android подключается к сеансу, визуализирует прогресс и запрашивает ввод пользователя только при необходимости.

Использование облачного агентского бэкенда дает несколько преимуществ:

  • Выполнение в фоновом режиме. Агенты бронирования работают автономно в облаке, поэтому прогресс не теряется, если мобильное приложение переходит в фоновый режим или теряет подключение к интернету.
  • Сложная оркестрация нескольких агентов. Агент-координатор может делегировать бронирования специализированным субагентам и управлять зависимостями между ними.
  • Отрисовка интерфейса независимо от клиента. Серверная часть динамически описывает структуру интерфейса, позволяя обновлять его макет без выпуска новой версии клиента.
booking-assistant.png
Помощник по бронированию показывает все бронирования, упорядоченные по типу мероприятия.

Учитывая эти преимущества, мы добавили в Jetpacker помощника по бронированию, который координирует бронирование авиабилетов, отелей, музеев и ресторанов. Давайте посмотрим, как мы создали систему из нескольких агентов на основе Agent Development Kit (ADK) с протоколами Agent-User Interaction (AG-UI) и Agent-to-User Interface (A2UI), чтобы отправлять и показывать интерактивные карточки в Jetpack Compose.

Как выполнять сложные рабочие процессы с помощью агентов ADK

Вместо того чтобы вручную координировать поток оркестрации с помощью пользовательских конечных точек REST или сложных веб-сокетов, вы можете использовать Agent Development Kit (ADK). С помощью 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.

AG-UI – это двунаправленный протокол транспортного уровня, который стандартизирует типы сообщений между агентами и клиентами интерфейса. Агент может сообщать клиенту о событиях жизненного цикла, текстовых сообщениях, вызовах инструментов и управлении состоянием. Клиент, в свою очередь, может отправлять агенту текстовые сообщения пользователя, результаты вызова инструментов и события настраиваемых действий.

На стороне сервера он возвращает обновления, отформатированные как стандартные события, отправленные сервером (например, event: TEXT_MESSAGE_CONTENT, содержащий дельту JSON). В 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"]
)

Благодаря этой сгенерированной системной инструкции LLM опирается на макет схемы и точно знает, как формулировать обновления компонентов, которые может отображать клиент Android.

Нативная отрисовка A2UI с помощью Jetpack Compose

Чтобы отрисовывать эти деревья компонентов на Android, используйте новую библиотеку Jetpack Compose A2UI Renderer.

Сначала добавьте зависимости в файл 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, с composable-функцией 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 обработайте сообщения A2UI с помощью A2uiMessageProcessor и обновите активные поверхности:

// 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 соберите эти поверхности и отрисуйте каждую из них, используя официальную composable-функцию A2uiSurface из androidx.compose.material3:material3-a2ui. 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 позволяет облачному агенту динамически описывать интерактивные компоненты интерфейса, сохраняя клиентское приложение полностью отделенным от пошаговой логики оркестрации серверной части.

Ознакомьтесь с полным исходным кодом Jetpacker на GitHub и посмотрите видео Build Intelligent Android apps with Google’s AI (Как создавать умные приложения для Android с помощью ИИ от Google), чтобы узнать больше о том, как интегрировать агентные рабочие процессы непосредственно в приложение.

Другие части этой серии записей в блоге:
▪️ Часть 1. Знакомство с приложением и общий обзор.
📱 Часть 2. Искусственный интеллект на устройстве. Узнайте, как с помощью GenAI API в ML Kit и Gemini Nano создавать функции, ориентированные на конфиденциальность, например обобщение маршрутов, анализ чеков и локальную обработку аудио.
☁️ Часть 3. Гибридные и облачные рассуждения. Узнайте, как использовать Firebase AI Logic, чтобы обосновывать ответы LLM на основе реальных данных, например Google Карт и веб-контекста.
⚙️ Часть 4. Интеграция системы. Интеграция с интеллектуальной системой Android с помощью AppFunctions.
🤖 Часть 5 (эта статья): Рабочие процессы агентов в приложении. Добавьте в приложение помощников по бронированию на базе A2UI и ADK.

Хотите узнать больше о разработке для Android? Подпишитесь на Android Developers в YouTube или LinkedIn.

Все фрагменты кода в этой записи блога защищены следующим уведомлением об авторских правах:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0
Автор:
Продолжить чтение