Criar apps Android inteligentes: inferência híbrida e na nuvem

Bem-vindo de volta à série de postagens do blog "Crie apps Android inteligentes", em que pegamos um app Android básico e o transformamos em uma experiência personalizada, inteligente e agêntica. Na postagem anterior, mostramos como criar recursos inteligentes no dispositivo usando o Gemini Nano com a API Prompt do ML Kit.

Nesta postagem, vamos mostrar como usar o Firebase AI Logic para criar recursos de IA híbridos e hospedados na nuvem: 

• Fundamentar respostas no contexto do mundo real
• Como rotear solicitações dinamicamente entre a execução na nuvem e a execução local usando a inferência híbrida
• Como traduzir conteúdo com sistemas de roteamento personalizados

Às vezes, um caso de uso exige modelos de IA com maior conhecimento do mundo, uma janela de contexto muito maior ou a capacidade de lidar com consultas complexas. Nesses cenários, podemos usar modelos de nuvem. 

Em outros momentos, você quer o melhor dos dois mundos: usar a inferência híbrida para executar no dispositivo quando disponível e reduzir custos, além de usar a nuvem para garantir a compatibilidade com todos os dispositivos.

Vamos analisar como implementamos três recursos de nuvem e híbridos no Jetpacker:

• um assistente de museu com embasamento na Web
• rascunho híbrido de avaliação de restaurante
• chat de suporte do hotel com tradução simultânea personalizada.

Use o embasamento de LLM para informações atualizadas. Chatbot assistente de museu com embasamento de LLM

O Assistente de museu é um chatbot interativo criado para ajudar os usuários a planejar visitas a museus. Ele oferece aos visitantes detalhes atualizados sobre exposições específicas, horários de funcionamento atuais, preços de ingressos e muito mais.

Ao criar recursos de IA, é comum ter dificuldade para fazer o modelo responder com informações reais, precisas e específicas. Embora os modelos de nuvem tenham grandes quantidades de conhecimento sobre o mundo, eles podem não saber sobre exposições sazonais ou o horário de funcionamento do dia.

Para diminuir essa lacuna, podemos usar técnicas de embasamento para adicionar mais contexto à janela de contexto do modelo. O SDK Firebase AI Logic oferece suporte a três tipos de embasamento:

• Fundamentação de URL:fundamenta respostas usando conteúdo de uma página da Web específica (por exemplo, preços atuais de passagens ou regras de museus).
• Embasamento da Pesquisa Google:permite que o modelo consulte o índice da Pesquisa Google em tempo real para obter detalhes atualizados.
• Embasamento do Maps:usa dados de localização do Google Maps.

No Jetpacker, construímos dinamicamente as ferramentas disponíveis com base nas flags de recursos ativadas e inicializamos o modelo generativo usando o SDK de IA do Firebase:

// implementation("com.google.firebase:firebase-ai-logic")

private var toolList = mutableListOf<Tool>()

init {
    if (ENABLE_SEARCH_GROUNDING) {
        toolList.add(Tool.googleSearch())
    }
    if (ENABLE_URL_GROUNDING) {
        toolList.add(Tool.urlContext())
    }
}

private val generativeModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3-flash",
        systemInstruction = content {
            text("You are a helpful museum assistant answering questions about a museum. Use plain text.")
        },
        tools = toolList
    )

Quando o usuário faz uma consulta ao assistente, se o embasamento de URL estiver ativado, vamos anexar os URLs de recursos específicos do museu diretamente ao comando:

val groundingText = if (FeatureFlags.ENABLE_URL_GROUNDING) {
    "\n If the following message above is about the rules and terms to visit Le Louvre, " +
    "if needed answer this urls ${urlList.joinToString()}"
} else {
    ""
}

val prompt = "$text $groundingText"

var response = chat.sendMessage(prompt)

Inferência híbrida: geração de avaliações no dispositivo com link direto do Maps

Nem toda tarefa de IA exige um modelo baseado na nuvem, e nem todo dispositivo está on-line. Para ajudar os desenvolvedores a equilibrar latência, custo e disponibilidade off-line, lançamos recentemente a API do Firebase para inferência híbrida.

No Jetpacker, o recurso avaliação de restaurante permite que os usuários avaliem tópicos selecionados e cria um rascunho de avaliação automaticamente. Para ativar esse recurso para todos os usuários, priorizamos a execução local com o Gemini Nano e usamos modelos de nuvem em dispositivos que não são compatíveis com o Gemini Nano. 

// implementation("com.google.firebase:firebase-ai-logic")
// implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta03")


// Initialize the model with hybrid routing configuration
val reviewModel = Firebase.ai.generativeModel(
    modelName = "gemini-3.1-flash-lite",
    onDeviceConfig = OnDeviceConfig(
        inferenceMode = InferenceMode.PREFER_ON_DEVICE
    )
)

A API Hybrid Inference oferece suporte a quatro modos de roteamento distintos:

• PREFER_ON_DEVICE:prioriza a execução local e volta para a nuvem se o Gemini Nano não estiver disponível.
• PREFER_IN_CLOUD:prioriza a execução na nuvem e volta para o dispositivo se ele ficar off-line.
• ONLY_ON_DEVICE:restringe a execução estritamente ao dispositivo.
• ONLY_IN_CLOUD:restringe a execução estritamente à nuvem.

Depois que a avaliação é gerada, ela é copiada para a área de transferência, e usamos uma intent para abrir o Google Maps diretamente na página de avaliações do restaurante, proporcionando uma experiência do usuário integrada:

private fun copyAndOpenMapsReview(context: Context, reviewText: String, placeId: String) {
    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
    val clip = ClipData.newPlainText("User Review", reviewText)
    clipboard.setPrimaryClip(clip)

    val uri = Uri.parse("https://search.google.com/local/writereview/mobile?placeid=$placeId")
    val intent = Intent(Intent.ACTION_VIEW, uri).apply {
        setPackage("com.google.android.apps.maps")
    }
    context.startActivity(intent)
}

Roteamento híbrido personalizado: tradução de chat de suporte a hotéis com personas simuladas

O chat de suporte do hotel foi criado para que os usuários finalizem a logística e verifiquem os detalhes do hotel. Esse recurso usa instruções do sistema para configurar um assistente de recepção localizado. Ao transmitir informações específicas, como o idioma de preferência e informações do hotel, nas instruções, podemos configurar uma persona de conversa que representa um hotel específico.

private val generativeModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        systemInstruction = content {
            text("""
              You are a helpful hotel receptionist at $hotelName only speaking $language. 
              Answer politely in $language. The bar closes at 10pm and breakfast is from 7am to 10am.
              There's someone at the desk 24/7. You can retrieve your luggage from the storage room 
              at the back of the lobby at any time.
              """)
        },
        modelName = "gemini-3-flash-preview"
    )

Como as respostas da recepção são no idioma local do hotel (por exemplo, francês para o Hotel Le Meurice em Paris), precisamos traduzir as mensagens para o idioma preferido do usuário.

Embora os modelos híbridos possam configurar preferências de roteamento simples, cenários complexos exigem uma lógica de roteamento personalizada. No Jetpacker, implementamos uma pilha de rotas personalizada que considera:

• Identificação de idioma:usando a API Kit de ML Language Identification no dispositivo, podemos detectar o idioma da mensagem recebida.
• Tradução no dispositivo (Gemini Nano): a API Prompt do Kit de ML permite traduzir pares de idiomas comuns diretamente no dispositivo, economizando largura de banda e custos de nuvem.
• Tradução na nuvem (Gemini 3 Flash): para idiomas mais complexos, usamos o Gemini Flash 3 para oferecer uma tradução de maior qualidade.

// implementation("com.google.android.gms:play-services-mlkit-language-id:17.0.0") 

// ML Kit for Language Identification (powered by Google Play Services)
private val languageIdentifier = LanguageIdentification.getClient()

// On-device translator model (prefer Gemini Nano) for translating common language pairs
private val hybridTranslationModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3-flash",
        onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE)
    )

// Cloud translator model for more complex language pairs
private val cloudTranslationModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3-flash"
    )

Quando uma mensagem precisa ser traduzida, identificamos o idioma de origem e aplicamos nossa lógica de roteamento personalizada, executando a tradução no dispositivo ou na nuvem:

fun translateMessage(message: SupportChatMessage) {
    viewModelScope.launch {
        // 1. Detect language using ML Kit Language Identification
        val sourceLang = try {
            Tasks.await(languageIdentifier.identifyLanguage(message.text))
        } catch (e: Exception) {
            "Undefined"
        }

        // 2. Custom routing: we've verified the translation quality for English and Korean with Gemini Nano, and will translate message on-device for those two languages
        val routeToCloud = sourceLang != "en" && sourceLang != "kr"

        val prompt = "Translate the following text to $selectedLanguage. Just return the translated sentence: ${message.text}."

        val (translatedText, routePrefix) = if (routeToCloud) {
            val result = cloudTranslationModel.generateContent(prompt)
            result.text to "[Cloud]"
        } else {
            val result = hybridTranslationModel.generateContent(prompt)
            result.text to "[On-Device]"
        }

        if (translatedText != null) {
            _translations.update { current ->
                current + (message.id to "$routePrefix: $translatedText")
            }
        }
    }
}

Neste exemplo, a lógica de roteamento personalizada considera apenas o idioma de origem e de destino da tradução. No entanto, dependendo do caso de uso do app, é possível expandir a lógica de roteamento para incluir outros fatores, como a versão do modelo no dispositivo, a conectividade de rede, o status da bateria e muito mais.

Proteção dos pipelines de IA: Firebase App Check

Por fim, o uso de IA na nuvem abre possibilidades de abuso de chaves de API ou faturamento não autorizado. Para proteger as chamadas de API, integramos o Firebase App Check usando a Play Integrity (produção) e o provedor de depuração local (para desenvolvimento local ou emuladores).

No arquivo JetPackerApplication.kt, instalamos o provedor de depuração na inicialização e acionamos a autenticação anônima para estabelecer uma sessão de usuário segura:

//  implementation("com.google.firebase:firebase-appcheck-playintegrity") 
//  implementation("com.google.firebase:firebase-appcheck-debug")  
//  implementation("com.google.firebase:firebase-auth") 

override fun onCreate() {
    super.onCreate()
    Firebase.initialize(context = this)
    Firebase.appCheck.installAppCheckProviderFactory(
        DebugAppCheckProviderFactory.getInstance()
    )
    Firebase.auth.signInAnonymously()
}

Ao criar localmente em um emulador, o App Check imprime um segredo de token local no logcat:

Enter this debug secret into the allow list in the Firebase Console: a8c2dd4c-xxxx-xxxx-xxxx-ef6c114ba27e

Depois de registrado no console do Firebase, o App Check verifica e autentica totalmente as solicitações locais, protegendo nosso back-end e permitindo que testemos o app localmente.

Conclusão

Ao combinar recursos de modelo de nuvem (fundamentação, instruções do sistema) com recursos no dispositivo (roteamento híbrido, tradução, verificações de apps de segurança), criamos um app de viagens inteligente, seguro e disponível off-line.

Confira o código-fonte completo do Jetpacker no GitHub (em inglês) e consulte a documentação do Firebase para começar:

Documentação do Firebase AI Logic
API Firebase Hybrid Inference

Saiba mais

Confira as outras partes desta série de postagens do blog:

Parte 1:introdução ao app e uma visão geral de alto nível.
Parte 2: inteligência no dispositivo. Aprofunde-se nas APIs GenAI do Kit de ML e no Gemini Nano para criar recursos com foco na privacidade, como resumo de itinerários, análise de recibos e processamento de áudio local.
Parte 3 (esta postagem!): Raciocínio híbrido e de nuvem. Saiba como usar o Firebase AI Logic para embasar respostas de LLMs em dados do mundo real, como o Google Maps e o contexto da Web.
Parte 4: integração de sistemas. Integração com o sistema de inteligência do Android usando AppFunctions. 
Parte 5 (em breve): fluxos de trabalho agênticos no app. Estenda o app com um assistente de agendamento completo com tecnologia A2UI e ADK.

Quer saber mais sobre desenvolvimento para Android? Siga o Android Developers no YouTube ou no LinkedIn.

Todos os snippets de código nesta postagem do blog seguem a seguinte notificação de direitos autorais:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0