Mit Firebase AI Logic können Sie KI‑basierte Android-Apps und ‑Funktionen mit hybrider Inferenz erstellen. Die hybride Inferenz ermöglicht die Ausführung von Inferenz mit On-Device-Modellen, sofern verfügbar, und den nahtlosen Rückgriff auf in der Cloud gehostete Modelle, falls nicht (und umgekehrt).
Auf dieser Seite wird beschrieben, wie Sie mit dem Client-SDK beginnen. Außerdem werden zusätzliche Konfigurationsoptionen und Funktionen wie die Temperatur erläutert.
Die On-Device-Inferenz über Firebase AI Logic wird für Android-Apps unterstützt, die das Firebase AI Logic SDK ab Version 17.10.0 (BoM ab Version 34.10.0) verwenden und auf bestimmten Geräten ausgeführt werden. Sie unterliegt den ML Kit-Nutzungsbedingungen sowie den Nutzungsbedingungen für die Aspekte von generativer KI in ML Kit.
Empfohlene Anwendungsfälle und unterstützte Funktionen
Empfohlene Anwendungsfälle
Die Verwendung eines On-Device-Modells für die Inferenz bietet folgende Vorteile:
- Besserer Datenschutz
- Lokaler Kontext
- Kostenlose Inferenz
- Offline-Funktionen
Die Verwendung von Hybrid-Funktionen bietet folgende Vorteile:
- Mehr Nutzer erreichen, indem Sie die Verfügbarkeit von On-Device-Modellen und die Internetverbindung berücksichtigen
Unterstützte Funktionen für die Inferenz auf dem Gerät
Die Inferenz auf dem Gerät unterstützt nur die einmalige Textgenerierung (nicht Chat)> mit Streaming- oder Nicht-Streaming-Ausgabe. Die folgenden Funktionen zur Textgenerierung werden unterstützt:
Text aus Text- und Bildeingaben generieren, insbesondere aus einem einzelnen Bitmap-Bild als Eingabe
Sehen Sie sich die Liste der Funktionen, die noch nicht für die Inferenz auf dem Gerät verfügbar sind, unten auf dieser Seite an.
Hinweis
Beachten Sie Folgendes:
Unterstützte APIs:
Für die In-Cloud-Inferenz wird der von Ihnen ausgewählte Gemini API-Anbieter verwendet (entweder Gemini Developer API oder Agent Platform Gemini API (formerly Vertex AI)).
Für die Inferenz auf dem Gerät wird die Prompt API aus ML Kit verwendet, die sich in der Betaphase befindet und nur auf bestimmten Geräten verfügbar ist.
Auf dieser Seite wird beschrieben, wie Sie loslegen.
Nachdem Sie die Standardeinrichtung abgeschlossen haben, können Sie sich die zusätzlichen Konfigurationsoptionen und Funktionen ansehen, z. B. das Einstellen der Temperatur.
Unterstützte Android-Geräte und ihre On-Device-Modelle
Eine Liste der unterstützten Geräte und ihrer On-Device-Modelle für die Inferenz auf dem Gerät (die die Prompt API aus ML Kit verwendet) finden Sie in der ML Kit-Dokumentation.
Jetzt starten
In dieser Anleitung werden die erforderlichen allgemeinen Einrichtungsschritte für alle unterstützten Prompts beschrieben, die Sie senden möchten.
Schritt 1: Firebase-Projekt einrichten und App mit Firebase verbinden
Melden Sie sich in der Firebase Console an und wählen Sie Ihr Firebase-Projekt aus.
Rufen Sie in derFirebaseConsole AI Services > AI Logic auf.
Klicken Sie auf Jetzt starten, um einen geführten Workflow zu starten, mit dem Sie die erforderlichen APIs und Ressourcen für Ihr Projekt einrichten können.
Folgen Sie bei Aufforderung der Anleitung auf dem Bildschirm, um Ihre App zu registrieren und die Firebase-Konfiguration hinzuzufügen.
Wenn Sie aufgefordert werden, einen „Gemini API-Anbieter“ auszuwählen, empfehlen wir Ihnen, die Gemini Developer API auszuwählen, mit der Sie schnell und kostenlos loslegen können.
Sie können die Agent Platform Gemini API (formerly Vertex AI) (und die damit verbundenen Abrechnungsanforderungen) jederzeit später einrichten.
Fahren Sie mit dem Workflow fort, um die erforderlichen APIs und zugehörigen Dienste für Firebase AI Logic einzurichten.
Ab Anfang Juli 2026 wird in dieser Phase des Workflows automatisch Firebase App Check für AI Logic erzwungen. ist ein wichtiger Dienst, der zum Schutz der Gemini API beiträgt, wenn direkt über Ihre App darauf zugegriffen wird. Im Rahmen der ersten Schritte (siehe Anleitung weiter unten) müssen Sie den App Check-Debug-Anbieter für die lokale Entwicklung konfigurieren, wenn App Check erzwungen wird.
Fahren Sie mit dem nächsten Schritt in dieser Anleitung fort, um Ihrer App die erforderlichen SDKs hinzuzufügen.
Schritt 2: Erforderliche SDKs hinzufügen
Das Firebase AI Logic SDK für Android (firebase-aifirebase-ai-ondevice
Fügen Sie in der Gradle-Datei Ihres Moduls (auf App-Ebene) (z. B. <project>/<app-module>/build.gradle.kts) die Abhängigkeiten für die Bibliotheken Firebase AI Logic und App Check für Android hinzu:
Kotlin
dependencies { // ... other androidx dependencies // Add the dependencies for the Firebase AI Logic and App Check libraries // Note that the on-device SDK is not yet included in the Firebase Android BoM implementation("com.google.firebase:firebase-ai:17.17.0") implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta05") implementation("com.google.firebase:firebase-appcheck-debug:19.4.1") }
Java
Für Java müssen Sie zwei zusätzliche Bibliotheken hinzufügen.
dependencies { // ... other androidx dependencies // Add the dependencies for the Firebase AI Logic and App Check libraries // Note that the on-device SDK is not yet included in the Firebase Android BoM implementation("com.google.firebase:firebase-ai:17.17.0") implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta05") implementation("com.google.firebase:firebase-appcheck-debug:19.4.1") // Required for one-shot operations (to use `ListenableFuture` from Guava Android) implementation("com.google.guava:guava:31.0.1-android") // Required for streaming operations (to use `Publisher` from Reactive Streams) implementation("org.reactivestreams:reactive-streams:1.0.4") }
Schritt 3: App Check-Debug-Anbieter für die lokale Entwicklung konfigurieren
Ab Anfang Juli 2026 wird im Rahmen des geführten Einrichtungsvorgangs für AI Logic in der Console automatisch Firebase App Check erzwungen, um die Gemini API zu schützen. Für die lokale Entwicklung müssen Sie den App Check-Debug-Anbieter konfigurieren, um die Geräteattestierung zu umgehen und gleichzeitig die Durchsetzung von App Check beizubehalten.
Konfigurieren Sie in Ihrem Debug-Build App Check so, dass die Debug-Provider-Factory verwendet wird:
Kotlin
Firebase.initialize(context = this) Firebase.appCheck.installAppCheckProviderFactory( DebugAppCheckProviderFactory.getInstance(), )Java
FirebaseApp.initializeApp(/*context=*/ this); FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance(); firebaseAppCheck.installAppCheckProviderFactory( DebugAppCheckProviderFactory.getInstance());Debug-Token abrufen:
Führen Sie Ihre App im Emulator oder auf Ihrem Testgerät aus.
Suchen Sie in Ihren Logs nach dem App Check-Debug-Token. Beispiel:
D DebugAppCheckProvider: Enter this debug secret into the allow list in the Firebase Console for your project: 123a4567-b89c-12d3-e456-789012345678Kopieren Sie das Token (z. B.
123a4567-b89c-12d3-e456-789012345678).
Registrieren Sie Ihr Debug-Token bei App Check:
Rufen Sie in der Firebase-Konsole den Tab Apps unter Sicherheit > App Check auf.
Suchen Sie Ihre App, klicken Sie auf das Dreipunkt-Menü () und wählen Sie dann Debug-Tokens verwalten aus.
Folgen Sie der Anleitung auf dem Bildschirm, um Ihr Debug-Token zu registrieren.
Weitere Informationen zum Debugging-Anbieter (einschließlich der Vorgehensweise zum Abrufen eines neuen Debugging-Tokens) finden Sie in der offiziellen App Check-Dokumentation.
Schritt 4: Prüfen, ob das On-Device-Modell verfügbar ist
Prüfen Sie mit FirebaseAIOnDevice, ob das On-Device-Modell verfügbar ist, und laden Sie es herunter, falls dies nicht der Fall ist.
Nach dem Herunterladen wird das Modell von AICore automatisch auf dem neuesten Stand gehalten. In den Notizen nach dem Snippet finden Sie weitere Informationen zu AICore und zum Verwalten des Downloads des On-Device-Modells.
Kotlin
val status = FirebaseAIOnDevice.checkStatus()
when (status) {
OnDeviceModelStatus.UNAVAILABLE -> {
Log.w(TAG, "On-device model is unavailable")
}
OnDeviceModelStatus.DOWNLOADABLE -> {
FirebaseAIOnDevice.download().collect { status ->
when (status) {
is DownloadStatus.DownloadStarted ->
Log.w(TAG, "Starting download - ${status.bytesToDownload}")
is DownloadStatus.DownloadInProgress ->
Log.w(TAG, "Download in progress ${status.totalBytesDownloaded} bytes downloaded")
is DownloadStatus.DownloadCompleted ->
Log.w(TAG, "On-device model download complete")
is DownloadStatus.DownloadFailed ->
Log.e(TAG, "Download failed ${status}")
}
}
}
OnDeviceModelStatus.DOWNLOADING -> {
Log.w(TAG, "On-device model is being downloaded")
}
OnDeviceModelStatus.AVAILABLE -> {
Log.w(TAG, "On-device model is available")
}
}
Java
Checking for and downloading the model is not yet available for Java.
However, all other APIs and interactions in this guide are available for Java.
Beachten Sie beim Herunterladen des On-Device-Modells Folgendes:
Wie lange das Herunterladen des On-Device-Modells dauert, hängt von vielen Faktoren ab, unter anderem von Ihrem Netzwerk.
Wenn in Ihrem Code ein On-Device-Modell für die primäre oder Fallback-Inferenz verwendet wird, muss das Modell frühzeitig im Lebenszyklus Ihrer App heruntergeladen werden, damit es verfügbar ist, bevor Endnutzer auf den Code in Ihrer App stoßen.
Wenn das On-Device-Modell bei einer On-Device-Inferenzanfrage nicht verfügbar ist, wird der Download des On-Device-Modells nicht automatisch durch das SDK ausgelöst. Das SDK greift entweder auf das in der Cloud gehostete Modell zurück oder löst eine Ausnahme aus (siehe Details zum Verhalten von Inferenzmodi).
AICore (ein Android-Systemdienst) verwaltet für Sie, welches Modell und welche Version heruntergeladen werden, hält das Modell auf dem neuesten Stand usw. Beachten Sie, dass auf dem Gerät nur ein Modell heruntergeladen wird. Wenn also eine andere App auf dem Gerät das On-Device-Modell zuvor erfolgreich heruntergeladen hat, wird bei dieser Prüfung zurückgegeben, dass das Modell verfügbar ist.
Latenzoptimierung
Um den ersten Inferenzaufruf zu optimieren, kann Ihre App warmup() aufrufen.
Dadurch wird das On-Device-Modell in den Arbeitsspeicher geladen und Laufzeitkomponenten werden initialisiert.
Schritt 5: Dienst initialisieren und Modellinstanz erstellen
|
Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen. |
Richten Sie Folgendes ein, bevor Sie eine Prompts-Anfrage an das Modell senden.
Initialisieren Sie den Dienst für den von Ihnen ausgewählten API-Anbieter.
Erstellen Sie eine
GenerativeModel-Instanz und legen Siemodeauf einen der folgenden Werte fest. Die Beschreibungen hier sind sehr allgemein gehalten. Details zum Verhalten dieser Modi finden Sie unter Inferenzmodus festlegen.PREFER_ON_DEVICE: Versuch, das On-Device-Modell zu verwenden. Andernfalls auf das in der Cloud gehostete Modell zurückgreifen.ONLY_ON_DEVICE: Es wird versucht, das On-Device-Modell zu verwenden. Andernfalls wird eine Ausnahme ausgelöst.PREFER_IN_CLOUD: Versuche, das in der Cloud gehostete Modell zu verwenden. Andernfalls greife auf das On-Device-Modell zurück.ONLY_IN_CLOUD: Versuche, das in der Cloud gehostete Modell zu verwenden. Andernfalls wird eine Ausnahme ausgelöst.
Kotlin
// Using this SDK to access on-device inference is an Experimental release and requires opt-in
@OptIn(PublicPreviewAPI::class)
// ...
// Initialize the Gemini Developer API backend service
// Create a GenerativeModel instance with a model that supports your use case
// Set the inference mode (like PREFER_ON_DEVICE to use the on-device model if available)
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
.generativeModel(
modelName = "MODEL_NAME",
onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE)
)
Java
// Initialize the Gemini Developer API backend service
// Create a GenerativeModel instance with a model that supports your use case
// Set the inference mode (like PREFER_ON_DEVICE to use the on-device model if available)
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
.generativeModel(
"MODEL_NAME",
new OnDeviceConfig(InferenceMode.PREFER_ON_DEVICE)
);
// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
Schritt 6: Prompt-Anfrage an ein Modell senden
In diesem Abschnitt erfahren Sie, wie Sie verschiedene Arten von Eingaben senden, um unterschiedliche Arten von Ausgaben zu generieren, darunter:
Text aus reinen Texteingaben generieren
| Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Erste Schritte dieser Anleitung durchgearbeitet haben. |
Mit generateContent() können Sie Text aus einem Prompt generieren, der Text enthält:
Kotlin
// Imports + initialization of Gemini API backend service + creation of model instance
// Provide a prompt that contains text
val prompt = "Write a story about a magic backpack."
// To generate text output, call generateContent with the text input
val response = model.generateContent(prompt)
print(response.text)
Java
// Imports + initialization of Gemini API backend service + creation of model instance
// Provide a prompt that contains text
Content prompt = new Content.Builder()
.addText("Write a story about a magic backpack.")
.build();
// To generate text output, call generateContent with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
@Override
public void onSuccess(GenerateContentResponse result) {
String resultText = result.getText();
System.out.println(resultText);
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
Beachten Sie, dass Firebase AI Logic auch das Streamen von Textantworten mit generateContentStream (anstelle von generateContent) unterstützt.
Text aus multimodalen Eingaben (Text und Bild) generieren
| Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Erste Schritte dieser Anleitung durchgearbeitet haben. |
Mit generateContent() können Sie Text aus einem Prompt generieren, der Text und bis zu einer Bilddatei (nur Bitmap) enthält. Geben Sie dazu den mimeType jeder Eingabedatei und die Datei selbst an.
Kotlin
// Imports + initialization of Gemini API backend service + creation of model instance
// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)
// Provide a prompt that includes the image specified above and text
val prompt = content {
image(bitmap)
text("What developer tool is this mascot from?")
}
// To generate text output, call generateContent with the prompt
val response = model.generateContent(prompt)
print(response.text)
Java
// Imports + initialization of Gemini API backend service + creation of model instance
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);
// Provide a prompt that includes the image specified above and text
Content content = new Content.Builder()
.addImage(bitmap)
.addText("What developer tool is this mascot from?")
.build();
// To generate text output, call generateContent with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
@Override
public void onSuccess(GenerateContentResponse result) {
String resultText = result.getText();
System.out.println(resultText);
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
Beachten Sie, dass Firebase AI Logic auch das Streamen von Textantworten mit generateContentStream (anstelle von generateContent) unterstützt.
Was kannst du sonst noch tun?
Für Ihre hybriden Anwendungen stehen verschiedene zusätzliche Konfigurationsoptionen und Funktionen zur Verfügung:
Ermitteln, ob die Inferenz auf dem Gerät oder in der Cloud verwendet wurde.
Mit der Modellkonfiguration Antworten steuern (z. B. Temperatur)
Funktionen, die noch nicht für die Inferenz auf dem Gerät verfügbar sind
Da es sich um eine experimentelle Version handelt, sind nicht alle Funktionen von Cloud-Modellen für die Inferenz auf dem Gerät verfügbar.
Die in diesem Abschnitt aufgeführten Funktionen sind noch nicht für die Inferenz auf dem Gerät verfügbar. Wenn Sie eine dieser Funktionen verwenden möchten, empfehlen wir Ihnen, den ONLY_IN_CLOUD-Inferenzmodus zu verwenden, um eine konsistentere Erfahrung zu erzielen.
Strukturierte Ausgabe generieren (z. B. JSON oder Enums)
Text aus anderen Bilddateieingabetypen als Bitmap generieren (Bild in den Speicher geladen)
Text aus mehreren Bilddateien generieren
Text aus Audio-, Video- und Dokumenteneingaben (z. B. PDFs) generieren
Bilder mit Gemini-Modellen generieren
Dateien über URLs in multimodalen Anfragen bereitstellen Sie müssen Dateien als Inline-Daten für On-Device-Modelle bereitstellen
Anfragen mit mehr als 4.000 Tokens (ca. 3.000 Wörter auf Englisch) senden.
Multi-Turn-Unterhaltung
Dem Modell Tools zur Verfügung stellen, die ihm bei der Generierung seiner Antwort helfen (z. B. Funktionsaufrufe, Code-Ausführung, URL-Kontext, Fundierung mit
Google Search und Fundierung mitGoogle Maps )
Beim KI-Monitoring in der Firebase Console werden keine Daten für die Inferenz auf dem Gerät (einschließlich Logs auf dem Gerät) angezeigt. Alle Inferenzen, für die ein in der Cloud gehostetes Modell verwendet wird, können jedoch wie andere Inferenzen über Firebase AI Logic überwacht werden.
Zusätzliche Einschränkungen
Zusätzlich zu den oben genannten Einschränkungen hat die Geräteinferenz die folgendenEinschränkungen(weitere Informationen finden Sie in der ML Kit-Dokumentation):
Der Endnutzer Ihrer App muss ein unterstütztes Gerät für die Inferenz auf dem Gerät verwenden.
Ihre App kann die Inferenz auf dem Gerät nur ausführen, wenn sie im Vordergrund ausgeführt wird.
Nur Englisch und Koreanisch wurden für die Inferenz auf dem Gerät validiert.
Das maximale Tokenlimit für die gesamte On-Device-Inferenzanfrage beträgt 4.000 Tokens. Wenn Ihre Anfragen dieses Limit überschreiten könnten, müssen Sie einen Inferenzmodus konfigurieren, der ein in der Cloud gehostetes Modell verwenden kann.
Wir empfehlen, Anwendungsfälle für die Inferenz auf dem Gerät zu vermeiden, die eine lange Ausgabe (mehr als 256 Tokens) erfordern.
AICore (ein Android-Systemdienst, der die On-Device-Modelle verwaltet) erzwingt ein Inferenzkontingent pro App. Wenn innerhalb kurzer Zeit zu viele API-Anfragen gestellt werden, wird eine
ErrorCode.BUSY-Antwort zurückgegeben. Wenn Sie diesen Fehler erhalten, sollten Sie die Anfrage mit exponentiellem Backoff wiederholen. Außerdem kannErrorCode.PER_APP_BATTERY_USE_QUOTA_EXCEEDEDzurückgegeben werden, wenn eine App ein Kontingent für lange Zeiträume (z. B. das Tageskontingent) überschreitet.
Feedback zu Firebase AI Logic geben