Mettre à jour dynamiquement votre application Firebase AI Logic avec Firebase Remote Config

Lorsque vous appelez Gemini API depuis votre application à l'aide d'un SDK Firebase AI Logic, 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 (nombre maximal de jetons, 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 plusieurs 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 antérieures 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 conditionnellement les modèles les plus récents et les plus performants sur des segments d'utilisateurs spécifiques (comme les bêta-testeurs).
  • Définissez l'emplacement où vous accédez au modèle afin qu'il soit plus proche de vos utilisateurs.
  • Effectuez des tests A/B sur différentes instructions et requêtes système, puis déployez progressivement les valeurs gagnantes auprès de vos utilisateurs.
  • Utilisez des flags de fonctionnalité pour afficher ou masquer rapidement les fonctionnalités d'IA générative dans votre application.

Firebase Remote Config fait tout cela et plus encore. Il vous permet de mettre à jour les valeurs des paramètres selon vos besoins et conditionnellement 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 spécifiques recommandés et décrit 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 dynamiquement le comportement de votre application sans avoir à la mettre à jour. C'est particulièrement utile pour les applications qui utilisent l'IA générative, où l'itération rapide et le réglage précis sont essentiels.

Cas d'utilisation essentiels de Remote Config avec les applications d'IA générative

Nous vous recommandons d'utiliser Remote Config avec Firebase AI Logic 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'elle est disponible.

  • Mettre à jour les instructions système et les paramètres de sécurité sans mettre à jour l'application : Stockez les instructions système et les paramètres de sécurité dans des paramètres Remote Config pour pouvoir les modifier à la demande si vous rencontrez des problèmes après le déploiement.

  • Réduisez les risques et appliquez la sécurité de l'IA : Utilisez les déploiements Remote Config pour déployer de manière sûre et progressive les modifications de 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 les 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 la position en fonction de la position du client : Utilisez les conditions Remote Config pour définir la position à partir de laquelle vous accédez au modèle en fonction de la position détectée du client.

  • Testez différents modèles : Testez rapidement différents modèles d'IA générative et passez de l'un à l'autre, ou accédez même à différents modèles pour différents segments d'utilisateurs, afin de trouver celui qui convient le mieux à votre cas d'utilisation spécifique.

  • Optimiser les performances du modèle : ajustez 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, requêtes et configurations de modèle en fonction des attributs du client : lorsque vous utilisez Remote Config avec Google Analytics, vous pouvez créer des conditions basées sur les attributs du client ou les 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 à vos utilisateurs sur les plates-formes Android, iOS et Web.

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

  • Contrôlez les coûts : ajustez à distance les modèles d'IA générative appelés, la fréquence à laquelle ils sont utilisés et configurez de manière dynamique les valeurs maximales des jetons de sortie en fonction de l'audience utilisateur pour réduire les coûts inutiles.

  • Optimisez l'expérience et les résultats de vos applications : utilisez A/B Testing avec Remote Config dans vos applications et jeux mobiles pour tester les modifications apportées aux paramètres de l'IA générative dans différents segments d'utilisateurs. Vous pourrez ainsi voir comment ces modifications affectent les métriques clés comme la rétention 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 des expériences agréables à 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 Firebase AI Logic. Vous allez apprendre à effectuer les tâches suivantes :

  • Extrayez et activez les paramètres tels que les noms de modèles 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. Vous pourrez ainsi passer d'un modèle à un autre ou modifier les instructions système sans mettre à jour l'application.
  • Contrôlez les paramètres à distance, en ajustant le comportement et les capacités du modèle selon vos besoins.

Prérequis

Ce guide part du principe que vous savez développer des applications pour votre plate-forme.

Avant de commencer, assurez-vous d'avoir effectué les actions suivantes :

  • Suivez le guide de démarrage Firebase AI Logic, qui décrit comment configurer votre projet Firebase, associer votre application à Firebase, ajouter le SDK, initialiser le service de backend pour le fournisseur "Gemini API" de votre choix et créer une instance de modèle.

  • Activez Google Analytics dans votre projet Firebase et ajoutez son SDK à votre application (obligatoire pour le ciblage conditionnel, comme la définition de l'emplacement où vous accédez au 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. Ensuite, dans le menu de navigation, développez Exécuter et sélectionnez Remote Config.
  2. Assurez-vous que Client est sélectionné dans le sélecteur Client/Server (Client/Serveur) en haut de la page.
  3. Pour commencer à créer un modèle client, cliquez sur Créer une configuration (ou sur Ajouter un paramètre si vous avez déjà utilisé des modèles clients).
  4. Définissez les paramètres que vous souhaitez contrôler avec Remote Config. Exemple :

    Nom du paramètre Description Type Valeur par défaut
    model_name Nom du modèle. Consultez les noms de modèles disponibles. Chaîne gemini-2.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. 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 Ne s'applique que si vous utilisez Vertex AI Gemini API.
     Contrôlez l'emplacement pour accéder au modèle. Vous pouvez définir des conditions pour configurer cette option en fonction de la localisation du client détectée par Google Analytics.
    Chaîne global
  5. Lorsque vous avez terminé d'ajouter des paramètres, cliquez sur Publier les modifications. Si ce n'est pas 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 la bibliothèque Remote Config et configurez Remote Config dans votre application.

Swift

Lors de la configuration de Firebase AI Logic, vous avez déjà ajouté le SDK Firebase à votre application, mais vous devrez également ajouter Remote Config.

  1. Dans Xcode, avec le projet ouvert, accédez à File > Add Package Dependencies (Fichier > Ajouter des dépendances de package).

  2. Sélectionnez firebase-ios-sdk, puis cliquez sur Add package (Ajouter le package).

  3. Dans le navigateur de projet, sélectionnez votre application > Cibles > votre application.

  4. Dans l'onglet Général, faites défiler la page jusqu'à Frameworks, Libraries, and Embedded Content (Frameworks, bibliothèques et contenu intégré).

  5. Cliquez sur +, sélectionnez FirebaseRemoteConfig, puis cliquez sur Add (Ajouter).

  6. Ajoutez l'importation FirebaseRemoteConfig à votre code :

    import FirebaseRemoteConfig
    
  7. Dans la classe appropriée pour votre application, initialisez Firebase et ajoutez Remote Config à la logique principale de votre application.

    Ici, vous inclurez Remote Config et l'écouteur en temps réel Remote Config en tant qu'importations afin que l'application puisse récupérer de nouvelles valeurs en temps réel et ajouter un intervalle de récupération minimal :

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

    Dans l'application de démarrage rapide, cela se trouve dans VertexAISampleApp, au sein de la classe AppDelegate.

Kotlin

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

    dependencies {
        implementation(platform("com.google.firebase:firebase-bom:33.15.0"))
        implementation("com.google.firebase:firebase-ai")
        implementation("com.google.firebase:firebase-config")
        // ... other dependencies
    }
    
  2. Ajoutez Remote Config à la logique principale de votre application. Ici, vous allez initialiser Remote Config et ajouter un intervalle de récupération minimal :

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

Java

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

    dependencies {
        implementation(platform("com.google.firebase:firebase-bom:33.15.0"))
        implementation("com.google.firebase:firebase-ai")
        implementation("com.google.firebase:firebase-config")
        // ... other dependencies
    }
    
  2. Ajoutez Remote Config à la logique principale de votre application. Ici, vous allez initialiser Remote Config et ajouter un intervalle de récupération minimal :

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

Web

  1. Ouvrez votre code dans un éditeur de texte et importez Remote Config :

    import { getRemoteConfig } from 'firebase/remote-config';
    
  2. Dans votre fonction principale et après l'initialisation de l'application Firebase pour le SDK Firebase AI Logic, initialisez Remote Config :

      // Initialize Remote Config and get a reference to the service
      const remoteConfig = getRemoteConfig(app);
    
  3. Définissez un intervalle de récupération minimal :

    remoteConfig.settings.minimumFetchIntervalMillis = 3600000;
    

Dart

  1. Depuis le répertoire de votre projet Flutter, installez et ajoutez Remote Config à l'aide de la commande suivante :

    flutter pub add firebase_remote_config
    
  2. Ouvrez ./lib/main.dart et ajoutez l'importation après les autres importations que vous avez ajoutées pour prendre en charge Firebase AI Logic :

    import 'package:firebase_vertexai/firebase_ai.dart';
    import 'package:firebase_core/firebase_core.dart';
    import 'package:firebase_remote_config/firebase_remote_config.dart';
    
  3. Ajoutez les variables _modelName, _systemInstructions et _prompt à votre application pour que nous puissions les utiliser ultérieurement :

    late final String _modelName;
    late final String _systemInstructions;
    late final String _prompt;
    
  4. Obtenez l'instance d'objet Remote Config et définissez l'intervalle minimal d'extraction pour autoriser des actualisations fréquentes. Veillez à ajouter cette ligne après l'initialisation de Firebase.

      final remoteConfig = FirebaseRemoteConfig.instance;
      await remoteConfig.setConfigSettings(RemoteConfigSettings(
        fetchTimeout: const Duration(seconds: 3600),
        minimumFetchInterval: const Duration(seconds: 3600),
      ));
    

Unity

  1. Ajoutez Remote Config à votre projet Unity en suivant ces instructions.

  2. Obtenez l'instance d'objet Remote Config et définissez l'intervalle minimal d'extraction pour autoriser des actualisations fréquentes. Veillez à ajouter cette ligne après l'initialisation de Firebase.

    var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
    const int MillisecondsPerSecond = 1000;
    await remoteConfig.SetConfigSettingsAsync(new ConfigSettings() {
      FetchTimeoutInMilliseconds = 3600 * MillisecondsPerSecond,
      MinimumFetchIntervalInMilliseconds = 3600 * MillisecondsPerSecond
    });
    

Étape 3 : Définissez 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 récupérer les valeurs du service Remote Config.

Swift

  1. Dans la console Firebase, ouvrez Remote Config.

  2. Dans l'onglet Paramètres, ouvrez le menu et 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-la 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 faire référence au fichier par défaut :

    // Set default values
    remoteConfig.setDefaults(fromPlist: "remote_config_defaults")
    

Kotlin

  1. Dans la console Firebase, ouvrez Remote Config.

  2. Dans l'onglet Paramètres, ouvrez le menu et 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é principal pour ajouter les valeurs par défaut après le configSettings que vous avez ajouté précédemment :

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

Java

  1. Dans la console Firebase, ouvrez Remote Config.

  2. Dans l'onglet Paramètres, ouvrez le menu et 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é principal pour ajouter les valeurs par défaut après le configSettings que vous avez ajouté précédemment :

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

Web

Vous pouvez définir les valeurs par défaut directement dans votre code :

// Set default Remote Config parameter values
remoteConfig.defaultConfig = {
  model_name: 'gemini-2.5-flash',
  system_instructions:
    'You are a helpful assistant who knows everything there is to know about Firebase!',
  prompt: 'I am a developer who wants to know more about Firebase!',
  vertex_location: 'global',
};

Dart

Vous pouvez définir les valeurs par défaut directement dans votre code :

remoteConfig.setDefaults(const {
  "model_name": "gemini-2.5-flash",
  "system_instructions": "You are a helpful assistant who knows everything there is to know about Firebase!",
  "prompt": "I am a developer who wants to know more about Firebase!",
  "vertex_location": "global"
});

Unity

Vous pouvez définir les valeurs par défaut directement dans votre code :

await remoteConfig.SetDefaultsAsync(
  new System.Collections.Generic.Dictionary<string, object>() {
    { "model_name", "gemini-2.5-flash" },
    { "system_instructions", "You are a helpful assistant who knows everything there is to know about Firebase!" },
    { "prompt", "I am a developer who wants to know more about Firebase!" },
    { "vertex_location", "global" }
  }
);

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

Swift

// 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é.

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

Web

  1. Ajoutez getValue et fetchAndActivate à vos importations :

    import { getValue, fetchAndActivate } from 'firebase/remote-config';
    
  2. Après le code que vous avez ajouté pour configurer les valeurs Remote Config par défaut, récupérez et activez la configuration, puis attribuez des valeurs aux constantes modelName, systemInstructions, prompt et vertexLocation.

    // Fetch and activate Remote Config.
    try {
      await fetchAndActivate(remoteConfig);
    } catch(err) {
      console.error('Remote Config fetch failed', err);
    }
    
    console.log('Remote Config fetched.');
    
    // Assign Remote Config values.
    const modelName = getValue(remoteConfig, 'model_name').asString();
    const systemInstructions = getValue(remoteConfig, 'system_instructions').asString();
    const prompt = getValue(remoteConfig, 'prompt').asString();
    const vertexLocation = getValue(remoteConfig, 'vertex_location').asString();
    

Dart

// Fetch and activate Remote Config.
remoteConfig.fetchAndActivate();

// Assign Remote Config values.
String? _modelName = remoteConfig.getString("model_name");
String? _systemInstructions = remoteConfig.getString("system_instructions");
String? _prompt = remoteConfig.getString("prompt");
String? _vertexLocation = remoteConfig.getString("vertex_location");

Unity

// Fetch and activate Remote Config values.
await remoteConfig.FetchAndActivateAsync();

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

Ajoutez un listener Remote Config en temps réel à votre application pour vous assurer que les modifications que vous apportez 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.

Swift

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

Kotlin

Vous pouvez également configurer une action dans l'activation addOnCompleteListener :

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

Vous pouvez également configurer une action dans l'activation addOnCompleteListener :

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

Web

Les écouteurs Remote Config en temps réel ne sont pas compatibles avec les applications Web.

Dart

// Add a real-time Remote Config listener
remoteConfig.onConfigUpdated.listen((event) async {
  await remoteConfig.activate();
});

Unity

// Add a real-time Remote Config listener to automatically update whenever
// a new template is published.
// Note: the parameters can be anonymous as they are unused.

remoteConfig.OnConfigUpdateListener += (_, _) => {
  remoteConfig.ActivateAsync();
};

Étape 6 : Mettez à jour les requêtes Gemini API pour utiliser les valeurs Remote Config

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page.

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.

Swift

// Initialize the Gemini Developer API backend service
// The Gemini Developer API doesn't support setting the location of a model
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` and add system instructions into its config
// Both the model name and the system instructions will be sourced from Remote Config
let modelName = remoteConfig.configValue(forKey: "model_name").stringValue
let systemInstructions = remoteConfig.configValue(forKey: "system_instructions").stringValue

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

// Provide a prompt that contains text
// The text in the prompt will be sourced from Remote Config
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)
}

Kotlin

// Initialize the Gemini Developer API backend service
// The Gemini Developer API doesn't support setting the location of a model
val ai = Firebase.ai(backend = GenerativeBackend.googleAI())

// Create a `GenerativeModel` and add system instructions into its config
// Both the model name and the system instructions will be sourced from Remote Config
val model = ai.generativeModel(
  modelName = remoteConfig.getString("model_name"),
  systemInstruction = content { text(remoteConfig.getString("system_instructions")) }
)

// To generate text output, call `generateContent` with the text input
// The text in the prompt will be sourced from Remote Config
val response = model.generateContent(remoteConfig.getString("prompt"))
print(response.text)

Java

// Initialize the Gemini Developer API backend service
// The Gemini Developer API doesn't support setting the location of a model
FirebaseAI ai = FirebaseAI.getInstance(GenerativeBackend.googleAI());

// Create a `GenerativeModel` and add system instructions into its config
// Both the model name and the system instructions will be sourced from Remote Config
GenerativeModel gm = ai.generativeModel(
        /* modelName */ remoteConfig.getString("model_name"),
        /* generationConfig (optional) */ null,
        /* safetySettings (optional) */ null,
        /* tools (optional) */ null,
        /* toolsConfig (optional) */ null,
        /* systemInstruction (optional) */ new Content.Builder().addText(
                remoteConfig.getString("system_instructions")).build(),
        /* requestOptions (optional) */ new RequestOptions()
);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// Provide a prompt that contains text
// The text in the prompt will be sourced from Remote Config
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);

Web

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
// The Gemini Developer API doesn't support setting the location of a model
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` and add system instructions into its config
// Both the model name and the system instructions will be sourced from Remote Config
const model = getGenerativeModel(ai, {
  model: modelName,
  systemInstruction: systemInstruction
});

// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  // The text in the prompt will be sourced from Remote Config
  const userPrompt = prompt;

  // To generate text output, call `generateContent` with the text input
  const result = await model.generateContent(userPrompt);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

Dart

// Initialize the Gemini Developer API backend service
// The Gemini Developer API doesn't support setting the location of a model
final ai = await FirebaseAI.googleAI();

// Create a `GenerativeModel` and add system instructions into its config
// Both the model name and the system instructions will be sourced from Remote Config
final model =
      ai.generativeModel(
        model: _modelName,
        systemInstruction: Content.system(_systemInstructions),
      );

// Provide a prompt that contains text
// The text in the prompt will be sourced from Remote Config
final _userPrompt = [Content.text(_prompt)];

// To generate text output, call `generateContent` with the text input
final response = await model.generateContent(_userPrompt);
print(response.text);

Unity

// Initialize the Gemini Developer API backend service
// The Gemini Developer API doesn't support setting the location of a model
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` and add system instructions into its config
// Both the model name and the system instructions will be sourced from Remote Config
var modelName = remoteConfig.GetValue("model_name").StringValue;
var systemInstructions = remoteConfig.GetValue("system_instructions").StringValue;

var model = ai.GetGenerativeModel(
  modelName: modelName,
  systemInstruction: ModelContent.Text(systemInstructions)
);

// Provide a prompt that contains text
// The text in the prompt will be sourced from Remote Config
var userPrompt = remoteConfig.GetValue("prompt").StringValue;

// To generate text output, call `GenerateContentAsync` with the text input
var response = await model.GenerateContentAsync(userPrompt);
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Étape 7 : Exécutez l'application

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

Étapes suivantes