Modifier à distance le nom du modèle 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
   

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:34.5.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:34.5.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 la variable _modelName à votre application pour pouvoir l'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
   });
   

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.

5. Dans Xcode, effectuez un clic droit sur votre application, puis sélectionnez Add Files (Ajouter des fichiers).

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 de paramètres par défaut :

   // Set default values for Remote Config parameters.
   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 for Remote Config parameters.
   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 for Remote Config parameters.
   mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);
   

Web

Vous pouvez définir la valeur par défaut du nom du modèle directement dans votre code :

// Set default values for Remote Config parameters.
remoteConfig.defaultConfig = {
  model_name: 'gemini-2.5-flash',
};

Dart

Vous pouvez définir la valeur par défaut du nom du modèle directement dans votre code :

// Set default values for Remote Config parameters.
remoteConfig.setDefaults(const {
  "model_name": "gemini-2.5-flash"
});

Unity

Vous pouvez définir la valeur par défaut du nom du modèle directement dans votre code :

// Set default values for Remote Config parameters.
await remoteConfig.SetDefaultsAsync(
  new System.Collections.Generic.Dictionary<string, object>() {
    { "model_name", "gemini-2.5-flash" }
  }
);

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. Localisez le code dans lequel vous spécifiez la valeur par défaut du nom du modèle. Juste après ce bloc de code, ajoutez le code suivant pour récupérer et activer la configuration, puis attribuer la valeur récupérée à la constante modelName.

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

Dart

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

// Assign Remote Config values.
String? _modelName = remoteConfig.getString("model_name");

Unity

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

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

Swift

import FirebaseAI

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
let modelName = remoteConfig.configValue(forKey: "model_name").stringValue
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: modelName
)

// ...

Kotlin

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = remoteConfig.getString("model_name")
)

// ...

Java

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
    .generativeModel(
      /* modelName */ remoteConfig.getString("model_name"),
      /* generationConfig (optional) */ null,
      /* safetySettings (optional) */ null,
      /* requestOptions (optional) */ new RequestOptions(),
      /* tools (optional) */ null,
      /* toolsConfig (optional) */ null,
      /* systemInstruction (optional) */ null,
    );

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// ...

Web

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
const model = getGenerativeModel(ai, {
  model: modelName
});

// ...

Dart

// ...

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
final model = FirebaseAI.googleAI().generativeModel(
  model: _modelName,
);

// ...

Unity

// ...

var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// When creating a `GenerativeModel` instance, source the model name value from Remote Config
var modelName = remoteConfig.GetValue("model_name").StringValue;
var model = ai.GetGenerativeModel(
  modelName: modelName
);

// ...