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 prendre une application Android de base et la transformer en une expérience personnalisée, intelligente et agentique. Dans notre précédent article, nous avons vu 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 vous pouvez tirer parti de Firebase AI Logic pour créer des fonctionnalités d'IA hébergées dans le cloud et hybrides :

• Ancrer les réponses dans le contexte du monde réel
• Router dynamiquement les requêtes entre l'exécution dans le 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 plus grande connaissance du monde, une fenêtre de contexte beaucoup plus grande ou la capacité à gérer des requêtes complexes. Dans ces scénarios, nous pouvons tirer parti des modèles cloud. 

D'autres fois, vous voulez le meilleur des deux mondes : utiliser l'inférence hybride pour exécuter 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
• une rédaction hybride d'avis sur un restaurant
• un chat d'assistance pour les hôtels avec traduction en direct à 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, les tarifs des billets, etc.

Lorsque vous créez des fonctionnalités d'IA, il est souvent difficile d'obtenir du modèle des réponses avec des informations réelles, précises et spécifiques. Bien que les modèles cloud possèdent une quantité massive 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 supplémentaire à 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 prix actuels des billets ou le règlement du 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 avec Maps: utilisation des données de localisation de Google Maps.

Dans Jetpacker, nous construisons dynamiquement les outils disponibles en fonction des indicateurs de fonctionnalité activés et nous 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 spécifiques du musée directement dans le prompt :

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 cloud, et tous les appareils ne sont pas connectés. Pour aider les développeurs à équilibrer la latence, le coût et la disponibilité hors connexion, nous avons récemment lancé l'API Firebase pour l'inférence hybride.

Dans Jetpacker, la fonctionnalité Avis sur un restaurant permet aux utilisateurs de consulter certains sujets et de rédiger automatiquement un avis. Pour activer cette fonctionnalité pour tous les utilisateurs, nous donnons la priorité à l'exécution locale avec Gemini Nano et nous revenons aux 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 revient au cloud si Gemini Nano n'est pas disponible.
• PREFER_IN_CLOUD : donne la priorité à l'exécution dans le cloud et revient à l'exécution sur l'appareil si l'appareil est hors connexion.
• 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 nous utilisons un intent 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 (telles que la langue préférée et les informations sur l'hôtel) dans les instructions, nous pouvons configurer un persona conversationnel 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 d'identification de la langue ML Kit 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 de réduire les coûts cloud.
• Traduction dans le cloud (Gemini 3 Flash) : pour les langues plus complexes, nous utilisons Gemini Flash 3 pour 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 à une utilisation abusive des clés API ou à une 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()
}

Lors de la compilation locale 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 vérifiées et authentifiées par App Check, ce qui protège notre backend tout en nous permettant de tester l'application localement.

Conclusion

En combinant les fonctionnalités des modèles cloud (ancrage, instructions système) avec les fonctionnalités sur l'appareil (routage hybride, traduction, vérifications de sécurité des applications), 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: présentation de l'application et aperçu général.
Partie 2: intelligence sur l'appareil. Présentation détaillée des API d'IA générative de ML Kit et de Gemini Nano pour créer des fonctionnalités axées sur la confidentialité, telles que 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 LLM dans des données réelles telles que Google Maps et le contexte Web.
Partie 4 : intégration au 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 les développeurs Android 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