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 flags 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 mise à jour de 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, afin de 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 dynamiquement les valeurs de jeton de sortie maximales en fonction de l'audience utilisateur 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 leur impact sur des 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 part du principe que vous savez utiliser Xcode pour développer des applications pour les plates-formes Apple (comme iOS). 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 à votre application.
    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-2.0-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 Remote Config dans votre application

Ajoutez des dépendances Remote Config et configurez Remote Config dans votre application. Lors de la configuration de Vertex AI in Firebase, vous avez déjà ajouté le SDK Firebase à votre application, mais vous devez également ajouter Remote Config.

  1. Dans Xcode, à partir du projet ouvert, accédez à File > Add Package Dependencies (Fichier > Ajouter des dépendances de package).
  2. Sélectionnez firebase-ios-sdk, puis cliquez sur Ajouter un package.
  3. Dans Project Navigator, sélectionnez votre application > Cibles > votre application.
  4. Dans l'onglet Général, faites défiler la page jusqu'à Cadres, bibliothèques et contenus intégrés.
  5. Cliquez sur +, puis sélectionnez FirebaseRemoteConfig, puis cliquez sur Ajouter.

  6. Ajoutez l'importation FirebaseRemoteConfig à votre code:

    import FirebaseRemoteConfig

  7. Dans la classe appropriée pour votre application (dans l'application exemple, elle se trouve dans VertexAISampleApp, dans la classe AppDelegate), initialisez Firebase et ajoutez Remote Config à votre logique d'application principale.

    Ici, vous allez inclure Remote Config et l'écouteur en temps réel Remote Config en tant qu'importations afin que l'application puisse extraire de nouvelles valeurs en temps réel et ajouter un intervalle d'extraction minimal:

    let remoteConfig = RemoteConfig.remoteConfig()
let settings = RemoteConfigSettings()
settings.minimumFetchInterval = 3600
remoteConfig.configSettings = settings

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 afin que votre application soit fonctionnelle avant de se connecter au backend Remote Config, si l'accès réseau client est interrompu et/ou si aucune valeur n'est configurée sur le backend.

  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 .plist pour iOS, puis cliquez sur Télécharger le fichier.
  4. Enregistrez le fichier dans le répertoire de votre application (si vous utilisez l'application exemple, enregistrez-le dans FirebaseVertexAI/Sample/VertexAISample).
  5. Dans Xcode, effectuez un clic droit sur votre application, puis sélectionnez Add Files (Ajouter des fichiers). (Si vous utilisez l'exemple, effectuez un clic droit sur VertexAISample, puis sélectionnez Add Files to "VertexAISample" (Ajouter des fichiers à "VertexAISample").
  6. Sélectionnez remote_config_defaults.plist, puis cliquez sur Ajouter.

  7. Mettez à jour le code de votre application pour référencer le fichier de valeurs par défaut:

    // Set default values
remoteConfig.setDefaults(fromPlist: "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:

// Fetch and activate Remote Config values
remoteConfig.fetchAndActivate { status, error in
  if let error = error {
    print("Error fetching Remote Config: \(error.localizedDescription)")
  }
}

Cela devrait mettre à jour l'objet Remote Config chaque fois qu'un nouveau modèle Remote Config est publié.

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

Ajoutez un écouteur Remote Config en temps réel 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.

// Add real-time Remote Config
remoteConfig.addOnConfigUpdateListener { configUpdate, error in
  guard let configUpdate = configUpdate, error == nil else {
    print("Error listening for config updates: \(error?.localizedDescription ?? "No error available")")
    return
  }

  print("Updated keys: \(configUpdate.updatedKeys)")
  remoteConfig.activate { changed, error in
    guard error == nil else {
      print("Error activating config: \(error?.localizedDescription ?? "No error available")")
      return
    }
    print("Activated config successfully")
  }
}

Cela devrait mettre à jour l'objet Remote Config chaque fois qu'un nouveau modèle Remote Config est publié.

É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.

Créez des valeurs pour stocker les valeurs de votre modèle et des invites système. Le code suivant montre comment obtenir l'emplacement, le nom du modèle, les instructions système, l'invite utilisateur et l'emplacement Vertex AI à partir de Remote Config:

// Initialize the Vertex AI service
// Optionally specify a location in which to run the service and access the model
let vertexLocation = remoteConfig.configValue(forKey: "vertex_location").stringValue
let vertex = VertexAI.vertexAI(location: vertexLocation)

// Initialize the generative model with a model that supports your use case
// Specify a model that supports system instructions, like a Gemini 1.5 model
let modelName = remoteConfig.configValue(forKey: "model_name").stringValue
let systemInstructions = remoteConfig.configValue(forKey: "system_instructions").stringValue

let model = vertex.generativeModel(
  modelName: modelName,
  systemInstruction: ModelContent(role: "system", parts: systemInstructions)
)

// Provide a prompt that contains text
let userPrompt = remoteConfig.configValue(forKey: "prompt").stringValue

// To generate text output, call generateContent with the text input
let response = try await model.generateContent(userPrompt)
if let text = response.text {
  print(text)
}

Étape 7: Exécuter l'application

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

Étapes suivantes