Créer des applications Android intelligentes : inférence cloud et hybride

Bienvenue dans la série d'articles de blog Créer des applications Android intelligentes. Nous allons transformer une application Android de base en une expérience personnalisée, intelligente et agentique. Dans notre article précédent, nous avons exploré comment créer des fonctionnalités intelligentes sur l'appareil à l'aide de Gemini Nano via l'API Prompt de ML Kit.

Dans cet article, nous allons voir comment utiliser Firebase AI Logic pour créer des fonctionnalités d'IA hybrides et hébergées dans le cloud :

• Ancrer les réponses dans le contexte du monde réel
• Router dynamiquement les requêtes entre l'exécution cloud et l'exécution locale à l'aide de l'inférence hybride
• Traduire du contenu avec des systèmes de routage personnalisés

Parfois, un cas d'utilisation nécessite des modèles d'IA avec une meilleure connaissance du monde, une fenêtre de contexte beaucoup plus grande ou la capacité à traiter des requêtes complexes. Dans ces scénarios, nous pouvons exploiter des modèles cloud. 

Parfois, vous souhaitez profiter du meilleur des deux mondes : utiliser l'inférence hybride pour l'exécution sur l'appareil lorsque cela est possible afin de réduire les coûts, tout en revenant au cloud pour assurer la compatibilité avec tous les appareils.

Voyons comment nous avons implémenté trois fonctionnalités cloud et hybrides dans Jetpacker :

• un assistant de musée avec ancrage Web
• rédaction hybride d'avis sur des restaurants
• Chat d'assistance pour les hôtels avec traduction en direct et routage personnalisé.

Utiliser l'ancrage LLM pour obtenir des informations à jourChatbot d'assistant de musée avec ancrage LLM

L'assistant de musée est un chatbot interactif conçu pour aider les utilisateurs à planifier leurs visites de musées. Il fournit aux visiteurs des informations à jour sur des expositions spécifiques, les horaires d'ouverture actuels, le prix des billets et plus encore.

Lorsque vous créez des fonctionnalités d'IA, il est souvent difficile d'obtenir du modèle des réponses qui soient à jour, précises et spécifiques au monde réel. Bien que les modèles cloud possèdent d'énormes quantités de connaissances sur le monde, ils peuvent ne pas être au courant des expositions saisonnières ou des horaires d'ouverture du jour.

Pour combler cette lacune, nous pouvons utiliser des techniques d'ancrage afin d'ajouter du contexte à la fenêtre de contexte du modèle. Le SDK Firebase AI Logic est compatible avec trois types d'ancrage :

• Ancrage d'URL : ancrage des réponses à l'aide du contenu d'une page Web spécifique (par exemple, les tarifs actuels des billets ou les règles d'un musée).
• Ancrage avec la recherche Google : permet au modèle d'interroger l'index de recherche Google en temps réel pour obtenir des informations à jour.
• Ancrage Maps : utilise les données de localisation Google Maps.

Dans Jetpacker, nous construisons dynamiquement les outils disponibles en fonction des indicateurs de fonctionnalité activés et initialisons le modèle génératif à l'aide du SDK Firebase AI :

// 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
    )

Lorsque l'utilisateur interroge l'assistant, si l'ancrage d'URL est activé, nous ajoutons les URL de ressources de musée spécifiques directement dans la requête :

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)

Inférence hybride : génération d'avis sur l'appareil avec lien profond Maps

Toutes les tâches d'IA ne nécessitent pas de modèle basé sur le cloud, et tous les appareils ne sont pas connectés. Pour aider les développeurs à trouver le juste équilibre entre latence, coût et disponibilité hors connexion, nous avons récemment lancé l'API Firebase pour l'inférence hybride.

Dans Jetpacker, la fonctionnalité Avis sur les restaurants permet aux utilisateurs d'examiner certains sujets et de rédiger automatiquement un avis. Pour activer cette fonctionnalité pour tous les utilisateurs, nous privilégions l'exécution locale avec Gemini Nano et nous utilisons des modèles cloud sur les appareils qui ne sont pas compatibles avec 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
    )
)

L'API Hybrid Inference est compatible avec quatre modes de routage distincts :

• PREFER_ON_DEVICE : donne la priorité à l'exécution locale et repasse au cloud si Gemini Nano n'est pas disponible.
• PREFER_IN_CLOUD : donne la priorité à l'exécution dans le cloud et repasse à l'exécution sur l'appareil si celui-ci se déconnecte.
• ONLY_ON_DEVICE : limite l'exécution strictement à l'appareil.
• ONLY_IN_CLOUD : limite l'exécution strictement au cloud.

Une fois l'avis généré, nous le copions dans le presse-papiers et utilisons une intention pour ouvrir Google Maps directement sur la page d'avis du restaurant, offrant ainsi une expérience utilisateur fluide :

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

Routage hybride personnalisé : traduction du chat d'assistance pour les hôtels avec des personas simulés

Le chat d'assistance pour les hôtels a été conçu pour permettre aux utilisateurs de finaliser la logistique et de vérifier les informations sur les hôtels. Cette fonctionnalité utilise des instructions système pour configurer un assistant de réception localisé. En transmettant des informations spécifiques (comme la langue préférée et les informations sur l'hôtel) dans les instructions, nous pouvons configurer une personnalité conversationnelle représentant un hôtel spécifique.

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

Étant donné que les réponses de la réception sont dans la langue locale de l'hôtel (par exemple, le français pour l'hôtel Le Meurice à Paris), nous devons traduire les messages dans la langue préférée de l'utilisateur.

Bien que les modèles hybrides puissent configurer des préférences de routage simples, les scénarios complexes nécessitent une logique de routage personnalisée. Dans Jetpacker, nous implémentons une pile de routage personnalisée qui prend en compte les éléments suivants :

• Identification de la langue : à l'aide de l'API ML Kit Language Identification sur l'appareil, nous pouvons détecter la langue du message entrant.
• Traduction sur l'appareil (Gemini Nano) : l'API Prompt de ML Kit nous permet de traduire des paires de langues courantes directement sur l'appareil, ce qui permet d'économiser de la bande passante et des coûts cloud.
• Traduction dans le cloud (Gemini 3 Flash) : pour les langues plus complexes, nous utilisons Gemini 3 Flash afin d'obtenir une traduction de meilleure qualité.

// 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"
    )

Lorsqu'un message doit être traduit, nous identifions la langue source et appliquons notre logique de routage personnalisée, en exécutant la traduction sur l'appareil ou dans le cloud :

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

Dans cet exemple, la logique de routage personnalisée ne prend en compte que la langue source et la langue cible de la traduction. Toutefois, en fonction du cas d'utilisation de votre application, vous pouvez étendre la logique de routage pour inclure d'autres facteurs tels que la version du modèle sur l'appareil, la connectivité réseau, l'état de la batterie, etc.

Sécuriser les pipelines d'IA : Firebase App Check

Enfin, l'utilisation de l'IA dans le cloud ouvre la voie à l'utilisation abusive de clés API ou à la facturation non autorisée. Pour sécuriser les appels d'API, nous avons intégré Firebase App Check à l'aide de Play Integrity (production) et du fournisseur de débogage local (pour le développement local ou les émulateurs).

Dans le fichier JetPackerApplication.kt, nous installons le fournisseur de débogage au démarrage et déclenchons l'authentification anonyme pour établir une session utilisateur sécurisée :

//  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()
}

Lorsque vous compilez localement sur un émulateur, App Check imprime un secret de jeton local dans logcat :

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

Une fois enregistrées dans la console Firebase, les requêtes locales sont entièrement validées et authentifiées par App Check, ce qui protège notre backend tout en nous permettant de tester l'application en local.

Conclusion

En combinant les capacités des modèles cloud (ancrage, instructions système) avec les capacités sur l'appareil (routage hybride, traduction, vérifications de l'application de sécurité), nous avons créé une application de voyage intelligente, sécurisée et disponible hors connexion.

Consultez le code source complet de Jetpacker sur GitHub et explorez la documentation Firebase pour commencer :

Documentation Firebase AI Logic
API Firebase Hybrid Inference

En savoir plus

Consultez les autres parties de cette série d'articles de blog :

Partie 1 : Introduction à l'application et vue d'ensemble.
Partie 2 : Intelligence sur l'appareil. Découvrez en détail les API d'IA générative de ML Kit et Gemini Nano pour créer des fonctionnalités axées sur la confidentialité, comme la synthèse d'itinéraires, l'analyse de reçus et le traitement audio local.
Partie 3 (cet article) Raisonnement hybride et cloud. Découvrez comment utiliser Firebase AI Logic pour ancrer les réponses des LLM dans des données réelles telles que Google Maps et le contexte Web.
Partie 4 : intégration du système. Intégration au système d'intelligence Android à l'aide d'AppFunctions. 
Partie 5 (à venir) : workflows agentiques dans l'application. Étendez l'application avec un assistant de réservation de bout en bout optimisé par A2UI et ADK.

Vous souhaitez en savoir plus sur le développement Android ? Suivez Android Developers sur YouTube ou LinkedIn.

Tous les extraits de code de cet article de blog sont soumis à l'avis de droits d'auteur suivant :

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