Mettre à jour dynamiquement votre application Vertex AI in Firebase avec Firebase Remote Config

Lorsque vous appelez Gemini API à partir de votre application à l'aide d'un SDK Vertex AI in Firebase, votre requête contient un certain nombre de paramètres qui contrôlent les réponses de l'IA générative. Il s'agit généralement du nom du modèle, de la configuration de génération du modèle (jetons maximum, température, etc.), des paramètres de sécurité, des instructions système et des données d'invite.

Dans la plupart des cas, vous devrez modifier ces paramètres à la demande ou selon les besoins pour un certain nombre de scénarios:

  • Mettez à jour votre modèle d'IA générative sans publier de nouvelle application. Vous pouvez passer à des versions de modèle plus récentes et stables avant que les versions précédentes ne soient mises hors service, passer à des modèles moins coûteux ou plus performants en fonction des besoins et des attributs de vos utilisateurs, ou déployer de manière conditionnelle les derniers modèles sur des segments d'utilisateurs spécifiques (comme les testeurs bêta).
  • Définissez l'emplacement où vous accédez au modèle afin qu'il soit plus proche de vos utilisateurs.
  • Testez A/B différentes instructions et requêtes système, puis déployez progressivement les valeurs de test gagnantes auprès de vos utilisateurs.
  • Utilisez des indicateurs de fonctionnalité pour exposer ou masquer rapidement les fonctionnalités d'IA générative dans votre application.

Firebase Remote Config fait tout cela et plus encore, ce qui vous permet de mettre à jour les valeurs de paramètre si nécessaire et de manière conditionnelle pour les instances d'application qui correspondent aux caractéristiques que vous définissez dans la console Firebase, sans publier de nouvelle version de votre application.

Ce guide de solution fournit des cas d'utilisation recommandés spécifiques et explique comment ajouter Remote Config à votre application d'IA générative.

Accéder à l'implémentation du code

Pourquoi utiliser Firebase Remote Config avec votre application ?

Firebase Remote Config vous permet d'ajuster de manière dynamique le comportement de votre application sans avoir à la mettre à jour. Cette fonctionnalité est particulièrement efficace pour les applications qui utilisent l'IA générative, où l'itération rapide et l'ajustement sont cruciaux.

Cas d'utilisation essentiels pour Remote Config avec des applications d'IA générative

Nous vous recommandons d'utiliser Remote Config avec Vertex AI in Firebase pour les cas d'utilisation essentiels suivants:

  • Passer à la dernière version du modèle sans mettre à jour l'application:utilisez les paramètres Remote Config pour modifier le nom du modèle si nécessaire, afin de pouvoir passer à la dernière version de votre modèle Gemini préféré dès qu'il est disponible.
  • Mettre à jour les instructions système et les paramètres de sécurité sans mise à jour de l'application:stockez les instructions système et les paramètres de sécurité dans les paramètres Remote Config pour vous assurer de pouvoir les modifier à la demande si vous découvrez des problèmes après le déploiement.
  • Réduire les risques et appliquer la sécurité de l'IA:utilisez les déploiements Remote Config pour déployer progressivement et de manière sécurisée les modifications apportées à l'IA générative auprès de vos utilisateurs iOS et Android.

Cas d'utilisation avancés et recommandés pour Remote Config avec des applications d'IA générative

Après avoir instrumenté votre application avec Remote Config et Google Analytics, vous pouvez explorer des cas d'utilisation avancés:

  • Définir l'emplacement en fonction de l'emplacement du client:utilisez des conditions Remote Config pour définir l'emplacement du modèle en fonction de l'emplacement détecté du client.
  • Testez différents modèles: testez et passez rapidement d'un modèle d'IA générative à un autre, ou même déployez différents modèles dans différents segments d'utilisateurs, pour trouver le modèle le mieux adapté à votre cas d'utilisation spécifique.
  • Optimiser les performances du modèle: affinez les paramètres du modèle, tels que l'invite système, le nombre maximal de jetons de sortie, la température et d'autres paramètres.

  • Utiliser différentes instructions système, invites et configurations de modèle en fonction des attributs client:lorsque vous utilisez Remote Config avec Google Analytics, vous pouvez créer des conditions en fonction des attributs client ou des audiences personnalisées, et définir différents paramètres en fonction de ces attributs.

    Par exemple, si vous utilisez l'IA générative pour fournir une assistance technique dans votre application, vous pouvez définir des instructions système spécifiques à la plate-forme de l'application pour vous assurer que des instructions précises sont fournies aux utilisateurs de votre plate-forme Android, iOS et Web.

  • Personnalisez les expériences pour chaque utilisateur:utilisez la personnalisation Remote Config pour déterminer automatiquement les paramètres d'IA générative optimaux pour chaque utilisateur.

  • Contrôler les coûts:ajustez à distance les modèles d'IA générative appelés, leur fréquence d'utilisation et configurez de manière dynamique les valeurs de jeton de sortie maximales en fonction de l'audience des utilisateurs pour réduire les coûts inutiles.

  • Optimisez l'expérience et les résultats de l'application:utilisez A/B Testing avec Remote Config dans vos applications iOS, Android et Flutter pour tester les modifications apportées aux paramètres d'IA générative dans différents segments d'utilisateurs afin de voir comment elles affectent les métriques clés telles que la fidélisation et les revenus.

En instrumentant votre application d'IA générative avec Firebase Remote Config, vous pouvez créer des applications optimisées par l'IA flexibles, sûres et économiques, tout en offrant une expérience agréable à vos utilisateurs.

Ajouter Firebase Remote Config à votre application

Dans ce guide de solution, vous allez utiliser Firebase Remote Config pour mettre à jour dynamiquement les paramètres de votre application Android qui utilisent le SDK Vertex AI in Firebase. Vous allez apprendre à effectuer les tâches suivantes :

  • Extrayez et activez des paramètres tels que les noms de modèle et les instructions système à partir de Firebase Remote Config.
  • Mettez à jour vos appels Gemini API pour utiliser les paramètres récupérés de manière dynamique, ce qui vous permet de passer d'un modèle à un autre ou de modifier les instructions système sans mettre à jour l'application.
  • Contrôlez les paramètres à distance, en ajustant le comportement et les fonctionnalités du modèle si nécessaire.

Prérequis

Ce guide suppose que vous savez utiliser Android Studio pour développer des applications pour les plates-formes Android. Avant de commencer, assurez-vous d'avoir effectué les opérations suivantes:

  • Suivez le guide de démarrage du SDK Vertex AI in Firebase. Assurez-vous d'avoir effectué les opérations suivantes:

    1. Configurez un projet Firebase nouveau ou existant, y compris en utilisant le forfait Blaze et en activant les API requises.
    2. Associez votre application à Firebase, y compris en l'enregistrant et en ajoutant votre configuration Firebase.
    3. Ajoutez le SDK, puis initialisez le service Vertex AI et le modèle génératif dans votre application.

  • Activez Google Analytics dans votre projet et ajoutez son SDK à votre application (requis pour le ciblage conditionnel, comme le paramétrage de l'emplacement du service et du modèle en fonction de l'emplacement de l'appareil client).

Étape 1: Définissez les valeurs des paramètres dans la console Firebase

Créez un modèle Remote Config client et configurez les paramètres et les valeurs à extraire et à utiliser dans l'application.

  1. Ouvrez votre projet Firebase dans la console Firebase, puis, dans le menu de navigation, développez Run (Exécuter) et sélectionnez Remote Config.
  2. Assurez-vous que Client est sélectionné dans le sélecteur Client/Serveur en haut de la page Remote Config.
    • Si vous utilisez des modèles de client Remote Config pour la première fois, cliquez sur Create Configuration (Créer une configuration). Le volet Créer votre premier paramètre s'affiche.
    • Si vous utilisez déjà des modèles Remote Config, cliquez sur Ajouter un paramètre.

  3. Définissez les paramètres Remote Config suivants:

    Nom du paramètre Description Type Valeur par défaut
    model_name Nom du modèle. Pour obtenir des listes à jour des noms de modèles à utiliser dans votre code, consultez Noms de modèles disponibles. Chaîne gemini-1.5-flash
    system_instructions Les instructions système sont comme un "préambule" que vous ajoutez avant que le modèle ne soit exposé à d'autres instructions de l'utilisateur final pour influencer son comportement, en fonction de besoins et de cas d'utilisation spécifiques. Chaîne You are a helpful assistant who knows everything there is to know about Firebase!
    prompt Requête par défaut à utiliser avec votre fonctionnalité d'IA générative. Chaîne I am a developer who wants to know more about Firebase!
    vertex_location Vous pouvez éventuellement contrôler l'emplacement pour exécuter le service Vertex AI et accéder à un modèle. Vous pouvez définir des conditions pour configurer cette option en fonction de l'emplacement du client détecté par Google Analytics. Chaîne us-central1

  4. Lorsque vous avez terminé d'ajouter des paramètres, cliquez sur Publier les modifications. S'il ne s'agit pas d'un nouveau modèle Remote Config, examinez les modifications et cliquez à nouveau sur Publier les modifications.

Étape 2: Ajoutez et initialisez le SDK Remote Config dans votre application

Ajoutez des dépendances Remote Config et configurez Remote Config dans votre application.

  1. Ajoutez la dépendance Remote Config au fichier Gradle de votre module (au niveau de l'application) (généralement app/build.gradle.kts ou app/build.gradle):

    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. Ajoutez Remote Config à la logique d'application principale. Ici, vous allez initialiser Remote Config et ajouter un intervalle de récupération minimal:

    Kotlin 

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

Dans cet exemple, l'intervalle de récupération par défaut est de 3 600 secondes, mais nous vous recommandons de définir un intervalle de récupération minimal relativement faible dans votre code pendant le développement.

Étape 3: Définir les valeurs des paramètres dans l'application

Vous devez définir les valeurs de paramètre par défaut dans l'application dans l'objet Remote Config. Cela garantit que votre application se comporte comme prévu, même si elle ne peut pas extraire de valeurs du service Remote Config.

  1. Dans la console Firebase, ouvrez Remote Config.
  2. Dans l'onglet Paramètres, ouvrez le menu, puis sélectionnez Télécharger les valeurs par défaut.
  3. Lorsque vous y êtes invité, activez .xml pour Android, puis cliquez sur Télécharger le fichier.
  4. Enregistrez le fichier dans le répertoire de ressources XML de votre application.

  5. Mettez à jour votre fichier d'activité principale pour ajouter les valeurs par défaut après l'configSettings que vous avez ajoutée précédemment:

    Kotlin 

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

    Java 

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

Étape 4: Extrayez et activez les valeurs

Après avoir défini les valeurs par défaut, ajoutez les éléments suivants pour extraire et activer les valeurs:

Kotlin 

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

Étape 5:Ajoutez un écouteur Remote Config en temps réel

Ajoutez un écouteur Remote Config en temps réel à votre application pour vous assurer que les modifications apportées au modèle Remote Config sont propagées au client dès qu'elles sont mises à jour.

Le code suivant met à jour l'objet Remote Config chaque fois qu'une valeur de paramètre change. Vous pouvez également configurer une action dans l'activation addOnCompleteListener:

Kotlin 

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

Étape 6: Attribuez des valeurs Remote Config aux variables Vertex AI

Maintenant que Remote Config est entièrement configuré, mettez à jour votre code pour remplacer les valeurs codées en dur par des valeurs provenant de Remote Config.

Remplacez les valeurs codées en dur pour l'emplacement, le nom du modèle, les instructions système et l'invite utilisateur par les valeurs issues de Remote Config.

Kotlin 

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

Étape 7: Exécuter l'application

Créez et exécutez l'application, puis vérifiez qu'elle fonctionne. Modifiez votre configuration depuis la page Remote Config de la console Firebase, publiez les modifications et vérifiez le résultat.

Étapes suivantes