Vertex AI in der Firebase App mit Firebase Remote Config dynamisch aktualisieren

Wenn Sie die Gemini API über ein Vertex AI in Firebase SDK von Ihrer App aus aufrufen, enthält Ihre Anfrage eine Reihe von Parametern, mit denen generative KI-Antworten gesteuert werden. Dazu gehören in der Regel der Modellname, die Konfiguration der Modellgenerierung (z. B. maximale Tokens, Temperatur), Sicherheitseinstellungen, Systemanweisungen und Prompt-Daten.

In den meisten Fällen sollten Sie diese nach Bedarf oder für eine Reihe von Szenarien ändern:

  • Sie können Ihr generatives KI-Modell aktualisieren, ohne eine neue App zu veröffentlichen. Sie können auf neuere, stabile Modellversionen umstellen, bevor ältere Versionen eingestellt werden, auf kostengünstigere oder leistungsstärkere Modelle umsteigen, je nach den Anforderungen und Attributen Ihrer Nutzer, oder die neuesten und besten Modelle bedingt für bestimmte Nutzersegmente (z. B. Betatester) bereitstellen.
  • Legen Sie den Standort fest, von dem aus Sie auf das Modell zugreifen, damit es Ihren Nutzern näher ist.
  • Führen Sie A/B-Tests mit verschiedenen Systemanweisungen und Prompts durch und führen Sie die erfolgreichen Testwerte dann nach und nach für Ihre Nutzer ein.
  • Mithilfe von Feature-Flags können Sie generative AI-Funktionen in Ihrer App schnell ein- oder ausblenden.

Firebase Remote Config bietet noch mehr Funktionen. Sie können Parameterwerte bei Bedarf und bedingungslos für App-Instanzen aktualisieren, die den in der Firebase-Konsole festgelegten Merkmalen entsprechen, ohne eine neue Version Ihrer App zu veröffentlichen.

In diesem Lösungsleitfaden finden Sie empfohlene Anwendungsfälle und eine Beschreibung, wie Sie Remote Config in Ihre generative KI-App einbinden.

Codeimplementierung

Warum sollten Sie Firebase Remote Config in Ihrer App verwenden?

Mit Firebase Remote Config können Sie das Verhalten Ihrer App dynamisch anpassen, ohne dass App-Updates erforderlich sind. Das ist besonders nützlich für Apps, bei denen generative AI verwendet wird, bei denen schnelle Iterationen und Feinabstimmungen entscheidend sind.

Wichtige Anwendungsfälle für Remote Config mit Apps für generative KI

Wir empfehlen die Verwendung von Remote Config mit Vertex AI in Firebase für die folgenden wichtigen Anwendungsfälle:

  • Ohne App-Update auf die neueste Modellversion umstellen:Verwenden Sie Remote Config-Parameter, um den Modellnamen nach Bedarf zu ändern, damit Sie auf die neueste Version Ihres bevorzugten Gemini-Modells umstellen können, sobald sie verfügbar ist.
  • Systemanweisungen und Sicherheitseinstellungen ohne App-Update aktualisieren:Speichern Sie Systemanweisungen und Sicherheitseinstellungen in Remote Config-Parametern, damit Sie sie bei Bedarf ändern können, falls Sie nach der Bereitstellung Probleme feststellen.
  • Risiken reduzieren und KI-Sicherheit durchsetzen:Mit Remote ConfigRoll-outs können Sie generative KI-Änderungen sicher und schrittweise für Ihre iOS- und Android-Nutzer freigeben.

Erweiterte und empfohlene Anwendungsfälle für Remote Config mit Apps für generative KI

Nachdem Sie Ihre App mit Remote Config und Google Analytics instrumentiert haben, können Sie erweiterte Anwendungsfälle ausprobieren:

  • Standort basierend auf dem Standort des Clients festlegen:Mit Remote Config-Bedingungen können Sie den Standort des Modells basierend auf dem erkannten Standort des Clients festlegen.
  • Mit verschiedenen Modellen experimentieren: Sie können verschiedene generative KI-Modelle schnell testen und zwischen ihnen wechseln oder sogar verschiedene Modelle für verschiedene Nutzersegmente bereitstellen, um das für Ihren Anwendungsfall am besten geeignete Modell zu finden.
  • Modellleistung optimieren: Sie können Modellparameter wie den Systemprompt, die maximale Anzahl von Ausgabetokens, die Temperatur und andere Einstellungen optimieren.

  • Unterschiedliche Systemanweisungen, Prompts und Modellkonfigurationen basierend auf Clientattributen verwenden:Wenn Sie Remote Config mit Google Analytics verwenden, können Sie Bedingungen basierend auf Clientattributen oder benutzerdefinierten Zielgruppen erstellen und basierend auf diesen Attributen unterschiedliche Parameter festlegen.

    Wenn Sie beispielsweise generative KI für den technischen Support in Ihrer App verwenden, sollten Sie plattformspezifische Systemanweisungen festlegen, damit Android-, iOS- und Webnutzer korrekte Anweisungen erhalten.

  • Personalisierung für jeden Nutzer:Mit der Remote ConfigPersonalisierung können Sie automatisch die optimalen Einstellungen für die generative KI für jeden Nutzer ermitteln.

  • Kosten kontrollieren:Sie können per Fernzugriff festlegen, welche generativen KI-Modelle aufgerufen und wie häufig sie verwendet werden sollen. Außerdem können Sie die maximalen Ausgabetokenwerte basierend auf der Nutzergruppe dynamisch konfigurieren, um unnötige Kosten zu vermeiden.

  • App-Nutzung und Ergebnisse optimieren:Verwenden Sie A/B Testing mit Remote Config in Ihren iOS-, Android- und Flutter-Apps, um Änderungen an den Parametern für die generative KI in verschiedenen Nutzersegmenten zu testen und so zu sehen, wie sich diese auf wichtige Messwerte wie Bindung und Umsatz auswirken.

Wenn Sie Ihre App mit generativer KI mit Firebase Remote Config ausstatten, können Sie flexible, sichere und kostengünstige KI-gestützte Anwendungen entwickeln und gleichzeitig eine hervorragende Nutzererfahrung schaffen.

Firebase Remote Config zu Ihrer App hinzufügen

In diesem Lösungsleitfaden verwenden Sie Firebase Remote Config, um Parameter in Ihrer Android-App, die das Vertex AI in Firebase SDK verwenden, dynamisch zu aktualisieren. Nach Abschluss können Sie:

  • Rufen Sie Parameter wie Modellnamen und Systemanweisungen von Firebase Remote Config ab und aktivieren Sie sie.
  • Aktualisieren Sie Ihre Gemini API-Aufrufe, um die dynamisch abgerufenen Parameter zu verwenden. So können Sie ohne App-Update zwischen verschiedenen Modellen wechseln oder Systemanweisungen ändern.
  • Parameter per Fernzugriff steuern und Modellverhalten und -funktionen nach Bedarf anpassen

Vorbereitung

In diesem Leitfaden wird davon ausgegangen, dass Sie mit der Verwendung von Android Studio zum Entwickeln von Apps für Android-Plattformen vertraut sind. Bevor Sie beginnen, müssen Sie Folgendes tun:

  • Folgen Sie dem Einstiegsleitfaden für das Vertex AI in Firebase SDK. Achten Sie darauf, dass Sie Folgendes getan haben:

    1. Richten Sie ein neues oder vorhandenes Firebase-Projekt ein. Verwenden Sie dabei den Blaze-Preisplan und aktivieren Sie die erforderlichen APIs.
    2. Verbinden Sie Ihre App mit Firebase. Dazu müssen Sie Ihre App registrieren und die Firebase-Konfiguration hinzufügen.
    3. Fügen Sie das SDK hinzu und initialisieren Sie den Vertex AI-Dienst und das generative Modell in Ihrer App.

  • Aktivieren Sie Google Analytics in Ihrem Projekt und fügen Sie Ihrer App das SDK hinzu. Dies ist für das bedingte Targeting erforderlich, z. B. um den Standort des Dienstes und des Modells basierend auf dem Standort des Clientgeräts festzulegen.

Schritt 1: Parameterwerte in der Firebase-Konsole festlegen

Erstellen Sie eine Remote Config-Clientvorlage und konfigurieren Sie Parameter und Werte, die abgerufen und in der App verwendet werden sollen.

  1. Öffnen Sie Ihr Firebase-Projekt in der Firebase Console, maximieren Sie im Navigationsmenü die Option Ausführen und wählen Sie Remote Config aus.
  2. Achte darauf, dass oben auf der Seite Remote Config in der Auswahl Client/Server die Option Client ausgewählt ist.
    • Wenn Sie Remote Config-Clientvorlagen zum ersten Mal verwenden, klicken Sie auf Konfiguration erstellen. Der Bereich Ersten Parameter erstellen wird angezeigt.
    • Wenn Sie Remote Config-Vorlagen bereits verwendet haben, klicken Sie auf Parameter hinzufügen.

  3. Definieren Sie die folgenden Remote Config-Parameter:

    Parametername Beschreibung Typ Standardwert
    model_name Modellname. Aktuelle Listen der Modellnamen, die Sie in Ihrem Code verwenden können, finden Sie unter Verfügbare Modellnamen. String gemini-1.5-flash
    system_instructions Systemanweisungen sind wie eine „Präambel“, die Sie hinzufügen, bevor dem Modell weitere Anweisungen des Endnutzers zur Verfügung gestellt werden, um das Modellverhalten basierend auf spezifischen Anforderungen und Anwendungsfällen zu beeinflussen. String You are a helpful assistant who knows everything there is to know about Firebase!
    prompt Standardprompt für die generative KI-Funktion. String I am a developer who wants to know more about Firebase!
    vertex_location Optional können Sie den Speicherort festlegen, um den Vertex AI-Dienst auszuführen und auf ein Modell zuzugreifen. Sie können Bedingungen festlegen, um diese Option basierend auf dem von Google Analytics erkannten Clientstandort zu konfigurieren. String us-central1

  4. Wenn Sie alle Parameter hinzugefügt haben, klicken Sie auf Änderungen veröffentlichen. Wenn dies keine neue Remote Config-Vorlage ist, überprüfen Sie die Änderungen und klicken Sie noch einmal auf Änderungen veröffentlichen.

Schritt 2: Remote Config SDK in Ihrer App hinzufügen und initialisieren

Fügen Sie Remote Config-Abhängigkeiten hinzu und richten Sie Remote Config in Ihrer App ein.

  1. Fügen Sie der Gradle-Datei des Moduls (auf Anwendungsebene, in der Regel app/build.gradle.kts oder app/build.gradle) die Abhängigkeit Remote Config hinzu:

    dependencies {
    implementation(platform("com.google.firebase:firebase-bom:33.7.0"))
    implementation("com.google.firebase:firebase-vertexai")
    implementation("com.google.firebase:firebase-config")
    // ... other dependencies
}

  2. Fügen Sie Remote Config der Hauptanwendungslogik hinzu. Hier initialisierst du Remote Config und fügst ein Mindestabrufintervall hinzu:

    Kotlin+KTX 

    val remoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)

    Java 

    FirebaseRemoteConfig mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
    .setMinimumFetchIntervalInSeconds(3600)
    .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);

In diesem Beispiel beträgt das Standardabrufintervall 3.600 Sekunden. Wir empfehlen jedoch, während der Entwicklung ein relativ niedriges Mindestabrufintervall in Ihrem Code festzulegen.

Schritt 3: In-App-Parameterwerte festlegen

Sie sollten In-App-Standardparameterwerte im Remote Config-Objekt festlegen. So wird sichergestellt, dass sich Ihre App wie erwartet verhält, auch wenn keine Werte vom Remote Config-Dienst abgerufen werden können.

  1. Öffnen Sie in der Firebase-Konsole Remote Config.
  2. Öffnen Sie auf dem Tab Parameter das Menü und wählen Sie Standardwerte herunterladen aus.
  3. Aktivieren Sie auf Aufforderung .xml für Android und klicken Sie dann auf Datei herunterladen.
  4. Speichern Sie die Datei im XML-Ressourcenverzeichnis Ihrer App.

  5. Aktualisieren Sie Ihre Hauptaktivitätsdatei, indem Sie die Standardwerte nach der zuvor hinzugefügten configSettings einfügen:

    Kotlin+KTX 

    // Set default values.
remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java 

    // Set default values.
mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Schritt 4: Werte abrufen und aktivieren

Nachdem Sie die Standardwerte festgelegt haben, fügen Sie Folgendes hinzu, um Werte abzurufen und zu aktivieren:

Kotlin+KTX 

// Fetch and activate Remote Config values
remoteConfig.fetchAndActivate()
     .addOnCompleteListener(this) { task ->
          if (task.isSuccessful) {
              val updated = task.result
              Log.d(TAG, "Remote Config values fetched and activated: $updated")
          } else {
              Log.e(TAG, "Error fetching Remote Config", task.exception)
          }

Java 

  // Fetch and activate Remote Config values
  mFirebaseRemoteConfig.fetchAndActivate()
    .addOnCompleteListener(this, new OnCompleteListener<Boolean>() {
        @Override
        public void onComplete(@NonNull Task<Boolean> task) {
            if (task.isSuccessful()) {
                boolean updated = task.getResult();
                Log.d(TAG, "Config params updated: " + updated);
            } else {
                Log.e(TAG, "Error fetching Remote Config", task.exception)
            }
          }
    });

Schritt 5:Remote Config-Listener in Echtzeit hinzufügen

Fügen Sie Ihrer App einen Echtzeit-Remote Config-Listener hinzu, damit Änderungen an der Remote Config-Vorlage sofort an den Client weitergegeben werden.

Mit dem folgenden Code wird das Remote Config-Objekt jedes Mal aktualisiert, wenn sich ein Parameterwert ändert. Optional kannst du auch eine Aktion innerhalb der addOnCompleteListener-Aktivierung konfigurieren:

Kotlin+KTX 

      // Add a real-time Remote Config listener
      remoteConfig.addOnConfigUpdateListener(object : ConfigUpdateListener {
          override fun onUpdate(configUpdate : ConfigUpdate) {
              Log.d(ContentValues.TAG, "Updated keys: " + configUpdate.updatedKeys);
              remoteConfig.activate().addOnCompleteListener {
                  // Optionally, add an action to perform on update here.
              }
          }

          override fun onError(error : FirebaseRemoteConfigException) {
              Log.w(ContentValues.TAG, "Config update error with code: " + error.code, error)
          }
      }

Java 

  // Add a real-time Remote Config listener
  remoteConfig.addOnConfigUpdateListener(new ConfigUpdateListener() {
      @Override
      public void onUpdate(ConfigUpdate configUpdate) {
          Log.d(ContentValues.TAG, "Updated keys: " + configUpdate.getUpdatedKeys());
                remoteConfig.activate().addOnCompleteListener(new OnCompleteListener<Boolean>() {
                  @Override
                  public void onComplete(@NonNull Task<Boolean> task) {
                      // Optionally, add an action to perform on update here.
                  }
              });
          }

      @Override
      public void onError(FirebaseRemoteConfigException error) {
          Log.w(ContentValues.TAG, "Config update error with code: " + error.getCode(), error);
      }
  });

Schritt 6: Remote Config-Werte Vertex AI-Variablen zuweisen

Nachdem Remote Config vollständig konfiguriert ist, aktualisieren Sie Ihren Code, um hartcodierte Werte durch Werte aus Remote Config zu ersetzen.

Ersetzen Sie die hartcodierten Werte für Standort, Modellname, Systemanweisungen und Nutzeraufforderung durch die Werte aus Remote Config.

Kotlin+KTX 

// Initialize FirebaseVertexAI instance
// Optionally specify a location in which to run the service and access the model
val vertexAI = Firebase.vertexAI(location = remoteConfig.getString("vertex_location"))

// Initialize the Vertex AI service and the generative model
// Specify a model that supports system instructions, like a Gemini 1.5 model
val generativeModel = Firebase.vertexAI.generativeModel(
  modelName = remoteConfig.getString("model_name"),
  systemInstruction = content { text(remoteConfig.getString("system_instructions")) }
)

// To generate text output, call generateContent with the text input
val response = generativeModel.generateContent(remoteConfig.getString("prompt"))
print(response.text)

Java 

// Initialize FirebaseVertexAI instance
// Optionally specify a location in which to run the service and access the model
FirebaseVertexAI vertexAI = FirebaseVertexAI.getInstance(remoteConfig.getString("vertex_location"));

// Initialize the Vertex AI service and the generative model
// Specify a model that supports system instructions, like a Gemini 1.5 model
GenerativeModel gm = FirebaseVertexAI.getInstance().generativeModel(
  /* modelName */ remoteConfig.getString("model_name"),
  /* generationConfig (optional) */ null,
  /* safetySettings (optional) */ null,
  /* requestOptions (optional) */ new RequestOptions(),
  /* tools (optional) */ null,
  /* toolsConfig (optional) */ null,
  /* systemInstruction (optional) */ new Content.Builder().addText(remoteConfig.getString("system_instructions")).build()
);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// Provide a prompt that contains text
Content userPrompt = new Content.Builder()
 addText(remoteConfig.getString("prompt"))
 build();

// To generate text output, call generateContent with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(userPrompt);
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);

Schritt 7: App ausführen

Erstellen und führen Sie die App aus und prüfen Sie, ob sie funktioniert. Nehmen Sie in der Firebase Console auf der Seite Remote Config Änderungen an der Konfiguration vor, veröffentlichen Sie die Änderungen und prüfen Sie das Ergebnis.

Nächste Schritte