Hybride Funktionen in Android-Apps mit On-Device- und Cloud-basierten Modellen entwickeln

Mit Firebase AI Logic können Sie KI-gestützte Android-Apps und ‑Funktionen mit hybrider Inferenz erstellen. Die Hybrid-Inferenz ermöglicht die Ausführung von Inferenzen mit On-Device-Modellen, sofern verfügbar, und den nahtlosen Wechsel zu in der Cloud gehosteten Modellen (und umgekehrt).

Auf dieser Seite wird beschrieben, wie Sie mit dem Client SDK beginnen. Außerdem werden zusätzliche Konfigurationsoptionen und Funktionen vorgestellt.

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:

  • Erweiterter Datenschutz
  • Lokaler Kontext
  • Kostenlose Inferenz
  • Offline-Funktionen

• Die Verwendung der Hybrid-Funktionalität bietet folgende Vorteile:

  • Mehr Nutzer erreichen, indem Sie die Verfügbarkeit von On-Device-Modellen und die Internetverbindung berücksichtigen

Unterstützte Funktionen und Features für die On-Device-Inferenz

Die On-Device-Inferenz unterstützt nur die einstufige Textgenerierung (keinen Chat) mit Streaming- oder Nicht-Streaming-Ausgabe. Es unterstützt die folgenden Funktionen zur Textgenerierung:

• Text aus reinen Texteingaben generieren

• Text aus Text- und Bildeingaben generieren, insbesondere aus einem einzelnen Bitmap-Bild als Eingabe

Sehen Sie sich die Liste der noch nicht verfügbaren Funktionen für die On-Device-Inferenz 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 (entweder Gemini Developer API oder Agent Platform Gemini API (formerly Vertex AI)) verwendet.

  • Für die Inferenz auf dem Gerät wird die Prompt API von 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 diese Standardeinrichtung abgeschlossen haben, können Sie sich die zusätzlichen Konfigurationsoptionen und Funktionen ansehen.

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 On-Device-Inferenz (bei der die Prompt API aus ML Kit verwendet wird) finden Sie in der ML Kit-Dokumentation.

Jetzt starten

In dieser Anleitung wird die allgemeine Einrichtung beschrieben, die für jede unterstützte Prompts-Anfrage erforderlich ist, die Sie senden möchten.

Schritt 1: Firebase-Projekt einrichten und App mit Firebase verbinden

1. Melden Sie sich in der Firebase Console an und wählen Sie Ihr Firebase-Projekt aus.

   Sie haben noch kein Firebase-Projekt?

   Wenn Sie noch kein Firebase-Projekt haben, klicken Sie auf die Schaltfläche, um ein neues Firebase-Projekt zu erstellen, und verwenden Sie dann eine der folgenden Optionen:

   • Option 1: Erstellen Sie ein völlig neues Firebase-Projekt (und automatisch das zugrunde liegende Google Cloud-Projekt), indem Sie im ersten Schritt des Workflows einen neuen Projektnamen eingeben.

   • Option 2: „Firebase hinzufügen“ zu einem vorhandenen Google Cloud-Projekt, indem Sie unten auf der Seite auf Firebase dem Google Cloud-Projekt hinzufügen klicken. Geben Sie im ersten Schritt des Workflows den Projektnamen des vorhandenen Projekts ein und wählen Sie das Projekt dann aus der angezeigten Liste aus.

   Führen Sie die verbleibenden Schritte des Workflows auf dem Bildschirm aus, um ein Firebase-Projekt zu erstellen. Wenn Sie dazu aufgefordert werden, müssen Sie Google Analytics nicht einrichten, um die Firebase AI Logic SDKs zu verwenden.

2. Rufen Sie in der Firebase-Konsole AI Services > AI Logic auf.

3. Klicken Sie auf Jetzt starten, um einen geführten Workflow zu starten, der Sie bei der Einrichtung der erforderlichen APIs und Ressourcen für Ihr Projekt unterstützt.

4. Folgen Sie bei Bedarf der Anleitung auf dem Bildschirm, um Ihre App zu registrieren und die Firebase-Konfiguration hinzuzufügen.

5. Wenn Sie aufgefordert werden, einen „Gemini API-Anbieter“ auszuwählen, empfehlen wir die Gemini Developer API, 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.

6. Fahren Sie im 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. Das ist ein wichtiger Dienst, der zum Schutz von 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.

7. Fahren Sie mit dem nächsten Schritt in dieser Anleitung fort, um die erforderlichen SDKs zu Ihrer App hinzuzufügen.

Schritt 2: Erforderliche SDKs hinzufügen

Das Firebase AI Logic SDK für Android (firebase-ai) und das Firebase AI Logic On-Device SDK (firebase-ai-ondevice) bieten Zugriff auf die APIs für die Interaktion mit generativen Modellen.

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:

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:18.0.0")
  implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta06")
  implementation("com.google.firebase:firebase-appcheck-debug:20.0.0")
}

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:18.0.0")
  implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta06")
  implementation("com.google.firebase:firebase-appcheck-debug:20.0.0")

  // 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 Einrichtungsprozesses 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 Debug-Anbieter von App Check so konfigurieren, dass die Attestierung umgangen wird, während die Erzwingung von App Check beibehalten wird.

1. Konfigurieren Sie in Ihrem Debug-Build App Check so, dass die Debug-Anbieter-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());
   

2. Rufen Sie Ihr Debug-Token ab:

   1. Führen Sie die App im Emulator oder auf Ihrem Testgerät aus.

   2. 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-789012345678
      

   3. Kopieren Sie das Token (z. B. 123a4567-b89c-12d3-e456-789012345678).

3. Registrieren Sie Ihr Fehlerbehebungstoken bei App Check:

   1. Rufen Sie in der Firebase-Konsole den Tab Sicherheit > App Check > Apps auf.

   2. Suchen Sie Ihre App, klicken Sie auf das Dreipunkt-Menü more_vert und wählen Sie Debug-Tokens verwalten aus.

   3. Folgen Sie der Anleitung auf dem Bildschirm, um Ihr Debug-Token zu registrieren.

Weitere Informationen zum Debug-Anbieter (einschließlich des Abrufs eines neuen Debug-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 nicht.

Nach dem Herunterladen wird das Modell von AICore automatisch aktualisiert. Weitere Informationen zu AICore und zur Verwaltung des Downloads des On-Device-Modells finden Sie in den Hinweisen nach dem Snippet.

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

Checking for, downloading, and warming up 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, z. B. von Ihrem Netzwerk.

• Wenn Ihr Code ein On-Device-Modell für die primäre oder Fallback-Inferenz verwendet, achten Sie darauf, dass das Modell früh im Lebenszyklus Ihrer App heruntergeladen wird, damit es verfügbar ist, bevor Ihre Endnutzer den Code in Ihrer App sehen.

• 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 wird, 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, gibt diese Prüfung zurück, dass das Modell verfügbar ist.

Latenzoptimierung

Um den ersten Inferenzaufruf zu optimieren, kann Ihre App onDeviceExtension?.warmUp() aufrufen (derzeit nur für Kotlin verfügbar). Dadurch wird das On-Device-Modell in den Arbeitsspeicher geladen und die Laufzeitkomponenten werden initialisiert.

Schritt 5: Dienst initialisieren und Modellinstanz erstellen

Richten Sie Folgendes ein, bevor Sie eine Prompts-Anfrage an das Modell senden.

1. Initialisieren Sie den Dienst für den von Ihnen ausgewählten API-Anbieter.

2. Erstellen Sie eine GenerativeModel-Instanz und legen Sie mode auf 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: Versuche, das On-Device-Modell zu verwenden. Andernfalls greife auf das in der Cloud gehostete Modell zurück.

   • ONLY_ON_DEVICE: Versuche, das On-Device-Modell zu verwenden. Andernfalls wird eine Ausnahme ausgelöst.

   • PREFER_IN_CLOUD: Versucht, das in der Cloud gehostete Modell zu verwenden. Andernfalls wird auf das On-Device-Modell zurückgegriffen.

   • ONLY_IN_CLOUD: Versuche, das in der Cloud gehostete Modell zu verwenden. Andernfalls wird eine Ausnahme ausgelöst.

// 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 = "CLOUD_MODEL_NAME",
        onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE)
    )

// 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(
        "CLOUD_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:

• Generierten Text aus reinen Texteingaben generieren

• Generierter Text aus Text- und Bildeingaben (multimodal)

Generierter Text aus Nur-Text-Eingabe

Mit generateContent() können Sie Text aus einem Prompt generieren, der Text enthält:

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

// 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 Streaming von Textantworten mit generateContentStream (anstelle von generateContent) unterstützt.

Text aus Text- und Bild-Eingaben (multimodal) generieren

Mit generateContent() können Sie Text aus einem Prompt generieren, der Text und bis zu eine Bilddatei (nur Bitmap) enthält. Geben Sie dazu den mimeType jeder Eingabedatei und die Datei selbst an.

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

// 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 Streaming 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:

• Inferenzmodus festlegen

• Bestimmen, ob die Inferenz auf dem Gerät oder in der Cloud ausgeführt wurde.

• Geben Sie ein Modell an, das verwendet werden soll.

• Modellkonfiguration zum Steuern von Antworten verwenden

• Strukturierte Ausgabe generieren (z. B. JSON oder Enums):

Noch nicht verfügbare Funktionen für die On-Device-Inferenz

Da es sich um eine experimentelle Version handelt, sind nicht alle Funktionen von Cloud-Modellen für die On-Device-Inferenz verfügbar. Die folgenden Funktionen sind noch nicht für die On-Device-Inferenz verfügbar (sie sind aber in der Regel für die cloudbasierte Inferenz verfügbar).

• Bilder werden generiert

  • Kann auf das in der Cloud gehostete Modell zurückgreifen. Im ONLY_ON_DEVICE-Modus wird jedoch eine Ausnahme ausgelöst.

• Generierter Text aus anderen Bilddateieingabetypen als Bitmap (Bild in den Arbeitsspeicher geladen)

  • Kann auf das in der Cloud gehostete Modell zurückgreifen. Im ONLY_ON_DEVICE-Modus wird jedoch eine Ausnahme ausgelöst.

• Generierter Text aus einer reinen Bilddatei-Eingabe. Für die On-Device-Inferenz müssen Sie Text als Teil der multimodalen Anfrage bereitstellen.

  • Es kann auf das in der Cloud gehostete Modell zurückgegriffen werden. Im ONLY_ON_DEVICE-Modus wird jedoch eine Ausnahme ausgelöst.

• Generierter Text aus mehr als einer Bilddateieingabe

  • Kann auf das in der Cloud gehostete Modell zurückgreifen. Im ONLY_ON_DEVICE-Modus wird jedoch eine Ausnahme ausgelöst.

• Text aus Audio‑, Video‑ und Dokumenteingaben (z. B. PDFs) generieren

  • Kann auf das in der Cloud gehostete Modell zurückgreifen. Im ONLY_ON_DEVICE-Modus wird jedoch eine Ausnahme ausgelöst.

• Dateien mithilfe von URLs in multimodalen Anfragen bereitstellen. Für die On-Device-Inferenz müssen Sie ein einzelnes Bild als Bitmap bereitstellen.

  • Wenn Sie eine Datei-URL mit fileData (FileDataPart) angeben, kann auf das in der Cloud gehostete Modell zurückgegriffen werden. Im ONLY_ON_DEVICE-Modus wird eine Ausnahme ausgelöst.
  • Wenn Sie eine URL direkt in einen Text-Prompt einbetten, wird nicht automatisch auf das in der Cloud gehostete Modell zurückgegriffen. Eingebettete URLs werden vom On-Device-Modell ignoriert.

• Anfragen mit mehr als 4.000 Tokens (oder etwa 3.000 englischen Wörtern) senden

  • Kann auf das in der Cloud gehostete Modell zurückgreifen. Im ONLY_ON_DEVICE-Modus wird jedoch eine Ausnahme ausgelöst.

• Multi-Turn-Unterhaltung

  • Es wird nicht automatisch auf das in der Cloud gehostete Modell zurückgegriffen. Bei der On-Device-Inferenz wird der Prompt-Verlauf zu einem einzigen Text-Prompt verkettet. Da das On-Device-Modell nicht zwischen Rollen unterscheidet und den Verlauf als eine einzige Nachricht sieht, ist es nicht so präzise wie ein in der Cloud gehostetes Modell.
  • Wenn Sie die Unterhaltung in mehreren Runden verwenden möchten, empfehlen wir den Modus ONLY_IN_CLOUD.

• Dem Modell Tools zur Verfügung stellen, die es beim Generieren der Antwort unterstützen (z. B. Funktionsaufrufe, Code-Ausführung, URL-Kontext, Fundierung mit Google Search und Fundierung mit Google Maps)

  • Es wird nicht automatisch auf das in der Cloud gehostete Modell zurückgegriffen. Wenn Sie Tools verwenden möchten, empfehlen wir den Modus ONLY_IN_CLOUD.

Beim KI-Monitoring in der Firebase-Konsole werden keine Daten für die On-Device-Inferenz (einschließlich Geräteprotokolle) angezeigt. Alle Inferenzvorgänge, bei denen ein in der Cloud gehostetes Modell verwendet wird, können jedoch wie andere Inferenzvorgänge über Firebase AI Logic überwacht werden.

Zusätzliche Einschränkungen

Zusätzlich zu den oben genannten Einschränkungen gelten für die Inferenz auf dem Gerät die folgenden Einschränkungen (weitere Informationen finden Sie in der ML Kit-Dokumentation):

• Der Endnutzer Ihrer App muss ein unterstütztes Gerät für die On-Device-Inferenz verwenden.

• Ihre App kann nur dann Inferenz auf dem Gerät ausführen, wenn sie im Vordergrund ausgeführt wird.

• Nur Englisch und Koreanisch wurden für die On-Device-Inferenz validiert.

• Das maximale Tokenlimit für die gesamte On-Device-Inferenzanfrage beträgt 4.000 Tokens. Wenn Ihre Anfragen dieses Limit überschreiten könnten, sollten 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 Sie in kurzer Zeit zu viele API-Anfragen stellen, erhalten Sie eine ErrorCode.BUSY-Antwort. Wenn Sie diesen Fehler erhalten, sollten Sie den exponentiellen Backoff verwenden, um die Anfrage noch einmal zu senden. Außerdem kann ErrorCode.PER_APP_BATTERY_USE_QUOTA_EXCEEDED zurückgegeben werden, wenn eine App ein Kontingent für lange Zeiträume (z. B. ein Tageskontingent) überschreitet.

Feedback zu Firebase AI Logic geben