Intelligente Android-Apps entwickeln: Cloud- und hybride Inferenz

Willkommen zurück zur Blogpost-Reihe Intelligente Android-Apps entwickeln. In dieser Reihe verwandeln wir eine einfache Android-App in eine personalisierte, intelligente und agentische Anwendung. In unserem vorherigen Beitrag haben wir uns damit beschäftigt, wie intelligente On-Device-Funktionen mit Gemini Nano über die Prompt API von ML Kit entwickelt werden können.

In diesem Beitrag erfahren Sie, wie Sie Firebase AI Logic nutzen können, um cloudbasierte und hybride KI-Funktionen zu entwickeln: 

• Antworten in einen realen Kontext einbetten
• Anfragen mit Hybrid Inference dynamisch zwischen Cloud und lokaler Ausführung weiterleiten
• Inhalte mit benutzerdefinierten Routing-Systemen übersetzen

Manchmal sind für einen Anwendungsfall KI-Modelle mit mehr Weltwissen, einem viel größeren Kontextfenster oder der Fähigkeit, komplexe Anfragen zu verarbeiten, erforderlich. In diesen Fällen können wir Cloud-Modelle nutzen. 

Manchmal möchten Sie das Beste aus beiden Welten: Hybride Inferenz, die auf dem Gerät ausgeführt wird, wenn verfügbar, um die Kosten zu senken, und auf die Cloud zurückgreift, um die Kompatibilität für alle Geräte zu gewährleisten.

Sehen wir uns an, wie wir drei Cloud- und Hybridfunktionen in Jetpacker implementiert haben:

• ein Museumsassistent mit Web-Grundlage
• Erstellen von Restaurantrezensionen im Hybridmodus
• Chat-Support für Hotels mit benutzerdefinierter Live-Übersetzung.

LLM-Fundierung für aktuelle Informationen verwendenMuseumsassistent-Chatbot mit LLM-Fundierung

Der Museumsassistent ist ein interaktiver Chatbot, der Nutzern bei der Planung ihrer Museumsbesuche hilft. Besucher erhalten hier aktuelle Informationen zu bestimmten Ausstellungen, den aktuellen Öffnungszeiten, Ticketpreisen und mehr.

Bei der Entwicklung von KI-Funktionen ist es oft schwierig, das Modell dazu zu bringen, mit aktuellen, genauen und spezifischen Informationen aus der realen Welt zu antworten. Cloud-Modelle verfügen zwar über ein enormes Wissen über die Welt, wissen aber möglicherweise nicht über saisonale Ausstellungen oder die Öffnungszeiten des aktuellen Tages Bescheid.

Um diese Lücke zu schließen, können wir Grounding-Techniken verwenden, um dem Kontextfenster des Modells zusätzlichen Kontext hinzuzufügen. Das Firebase AI Logic SDK unterstützt drei Arten von Grounding:

• URL-Fundierung:Antworten werden auf Grundlage von Inhalten einer bestimmten Webseite fundiert, z.B. aktuelle Ticketpreise oder Museumsregeln.
• Fundierung mit der Google Suche:Das Modell kann den Google-Suchindex in Echtzeit nach aktuellen Details durchsuchen.
• Fundierung mit Google Maps:Hier werden Standortdaten von Google Maps verwendet.

In Jetpacker erstellen wir die verfügbaren Tools dynamisch basierend auf aktivierten Feature-Flags und initialisieren das generative Modell mit dem Firebase AI SDK:

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

Wenn der Nutzer den Assistenten fragt und die URL-Fundierung aktiviert ist, hängen wir die spezifischen Museumsressourcen-URLs direkt an den Prompt an:

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)

Hybride Inferenz: On-Device-Generierung von Rezensionen mit Maps-Deeplink

Nicht für jede KI-Aufgabe ist ein cloudbasiertes Modell erforderlich und nicht jedes Gerät ist online. Um Entwicklern zu helfen, ein Gleichgewicht zwischen Latenz, Kosten und Offlineverfügbarkeit zu finden, haben wir vor Kurzem die Firebase API for Hybrid Inference eingeführt.

Mit der Funktion Restaurantrezension in Jetpacker können Nutzer bestimmte Themen rezensieren und automatisch eine Rezension erstellen lassen. Damit diese Funktion für alle Nutzer verfügbar ist, wird die lokale Ausführung mit Gemini Nano priorisiert. Auf Geräten, die Gemini Nano nicht unterstützen, wird auf Cloud-Modelle zurückgegriffen. 

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

Die Hybrid Inference API unterstützt vier verschiedene Routing-Modi:

• PREFER_ON_DEVICE:Die lokale Ausführung hat Priorität. Wenn Gemini Nano nicht verfügbar ist, wird auf die Cloud zurückgegriffen.
• PREFER_IN_CLOUD:Die Ausführung in der Cloud wird priorisiert. Wenn das Gerät offline geht, wird auf die Ausführung auf dem Gerät zurückgegriffen.
• ONLY_ON_DEVICE:Die Ausführung wird streng auf das Gerät beschränkt.
• ONLY_IN_CLOUD:Die Ausführung wird ausschließlich auf die Cloud beschränkt.

Sobald die Rezension generiert wurde, kopieren wir sie in die Zwischenablage und öffnen Google Maps direkt auf der Rezensionsseite des Restaurants. So wird ein nahtloses Nutzererlebnis ermöglicht:

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

Benutzerdefiniertes hybrides Routing: Übersetzung von Hotel-Supportchats mit simulierten Identitäten

Der Chat für Hotelsupport wurde entwickelt, damit Nutzer die Logistik abschließen und Hoteldetails prüfen können. Bei dieser Funktion werden Systemanweisungen verwendet, um einen lokalisierten Rezeptionisten-Assistenten zu konfigurieren. Wenn wir bestimmte Informationen wie die bevorzugte Sprache und Hotelinformationen in den Anweisungen angeben, können wir eine Konversationspersona einrichten, die ein bestimmtes Hotel repräsentiert.

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

Da die Antworten des Rezeptionisten in der lokalen Sprache des Hotels verfasst sind (z. B. Französisch für das Hotel Le Meurice in Paris), müssen wir Nachrichten in die bevorzugte Sprache des Nutzers übersetzen.

Mit Hybridmodellen lassen sich zwar einfache Routing-Einstellungen konfigurieren, für komplexe Szenarien ist jedoch eine benutzerdefinierte Routing-Logik erforderlich. In Jetpacker implementieren wir einen benutzerdefinierten Routing-Stack, der Folgendes berücksichtigt:

• Spracherkennung:Mit der ML Kit Language Identification API auf dem Gerät kann die Sprache der eingehenden Nachricht erkannt werden.
• Übersetzung auf dem Gerät (Gemini Nano): Mit der Prompt API von ML Kit können wir gängige Sprachpaare direkt auf dem Gerät übersetzen und so Bandbreite und Cloud-Kosten sparen.
• Cloud-Übersetzung (Gemini 3 Flash): Bei komplexeren Sprachen verwenden wir Gemini 3 Flash, um eine Übersetzung in höherer Qualität zu erhalten.

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

Wenn eine Nachricht übersetzt werden muss, ermitteln wir die Ausgangssprache und wenden unsere benutzerdefinierte Routing-Logik an. Die Übersetzung erfolgt dann entweder auf dem Gerät oder in der 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")
            }
        }
    }
}

In diesem Beispiel wird bei der benutzerdefinierten Routing-Logik nur die Quell- und Zielsprache der Übersetzung berücksichtigt. Je nach Anwendungsfall Ihrer App können Sie die Routing-Logik jedoch um andere Faktoren wie die Modellversion auf dem Gerät, die Netzwerkverbindung und den Akkustand erweitern.

KI-Pipelines schützen: Firebase App Check

Schließlich birgt der Einsatz von KI in der Cloud die Gefahr von API-Schlüsselmissbrauch oder unautorisierter Abrechnung. Um API-Aufrufe zu schützen, haben wir Firebase App Check mit Play Integrity (Produktion) und dem lokalen Debug Provider (für die lokale Entwicklung oder Emulatoren) integriert.

In der Datei JetPackerApplication.kt installieren wir den Debugging-Anbieter beim Start und lösen die anonyme Authentifizierung aus, um eine sichere Nutzersitzung einzurichten:

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

Wenn Sie einen Build lokal auf einem Emulator ausführen, gibt App Check ein lokales Token-Secret in logcat aus:

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

Nach der Registrierung in der Firebase Console werden lokale Anfragen vollständig von App Check überprüft und authentifiziert. So wird unser Backend geschützt und wir können die App lokal testen.

Fazit

Durch die Kombination von Cloud-Modellfunktionen (Fundierung, Systemanweisungen) mit On-Device-Funktionen (Hybrid-Routing, Übersetzung, Sicherheits-App-Prüfungen) haben wir eine Reise-App entwickelt, die intelligent, sicher und offline verfügbar ist.

Vollständigen Quellcode für Jetpacker auf GitHub ansehen und Firebase-Dokumentation für den Einstieg:

Dokumentation zu Firebase AI Logic
Firebase Hybrid Inference API

Weitere Informationen

Weitere Teile dieser Blogpost-Reihe:

Teil 1:Einführung in die App und allgemeiner Überblick.
Teil 2: On-Device-KI. In diesem Beitrag geht es um die GenAI APIs und Gemini Nano von ML Kit, mit denen Sie datenschutzfreundliche Funktionen wie die Zusammenfassung von Routen, das Parsen von Belegen und die lokale Audioverarbeitung entwickeln können.
Teil 3 (dieser Beitrag!): Hybrid- und Cloud-Schlussfolgerungen. Hier erfahren Sie, wie Sie mit Firebase AI Logic LLM-Antworten auf realen Daten wie Google Maps und Webkontext basieren lassen.
Teil 4: Systemintegration. Integration in das Android-System für künstliche Intelligenz mit AppFunctions 
Teil 5 (demnächst verfügbar): Agentische In-App-Workflows. Erweitern Sie die App mit einem End-to-End-Buchungsassistenten, der auf A2UI und ADK basiert.

Möchten Sie mehr über die Android-Entwicklung erfahren? Folgen Sie Android Developers auf YouTube oder LinkedIn.

Für alle Code-Snippets in diesem Blogpost gilt der folgende Urheberrechtshinweis:

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