Gérer les modèles de version à l'aide de Remote Config

Swift

Dans le cadre de Firebase AI Logic configuration, vous avez déjà ajouté le SDK Firebase à votre application, mais vous devez également ajouter Remote Config.

1. Dans Xcode, une fois 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 un package).

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

4. Dans l'onglet General (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' Remote Config écouteur en temps réel en tant qu'importations afin que l'application puisse extraire de nouvelles valeurs en temps réel, et vous ajouterez un intervalle minimal d'extraction :

   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.13.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 initialiserez Remote Config et ajouterez un intervalle minimal d'extraction :

   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.13.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 initialiserez Remote Config et ajouterez un intervalle minimal d'extraction :

   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 une fois l'application Firebase initialisée pour Firebase AI Logic SDK, initialisez Remote Config :

     // Initialize Remote Config and get a reference to the service
     const remoteConfig = getRemoteConfig(app);
   

3. Définissez un intervalle minimal d'extraction :

   remoteConfig.settings.minimumFetchIntervalMillis = 3600000;
   

Dart

1. Dans 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 afin de pouvoir l'utiliser ultérieurement :

   late final String _modelName;
   late final String _systemInstructions;
   late final String _prompt;
   

4. Extrayez l'instance d'objet Remote Config et définissez l'intervalle minimal d'extraction pour effectuer régulièrement des actualisations. Veillez à ajouter cette opération 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. Extrayez l'instance d'objet Remote Config et définissez l'intervalle minimal d'extraction pour effectuer régulièrement des actualisations. Veillez à ajouter cette opération 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 Parameters (Paramètres), ouvrez le Menu, puis sélectionnez Download default values (Télécharger les valeurs par défaut).

3. Lorsque vous y êtes invité, activez .plist for iOS (.plist pour iOS), puis cliquez sur Download file (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 Add (Ajouter).

7. Mettez à jour le code de votre application pour faire référence au fichier par défaut :

   // Set default values for Remote Config parameters.
   remoteConfig.setDefaults(fromPlist: "remote_config_defaults")
   

Kotlin

1. Dans la Firebase console, ouvrez Remote Config.

2. Dans l'onglet Parameters (Paramètres), ouvrez le Menu, puis sélectionnez Download default values(Télécharger les valeurs par défaut).

3. Lorsque vous y êtes invité, activez .xml for Android (.xml pour Android), puis cliquez sur Download file (Télécharger le fichier).

4. Enregistrez le fichier dans le répertoire des 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 Parameters (Paramètres), ouvrez le Menu, puis sélectionnez Download default values(Télécharger les valeurs par défaut).

3. Lorsque vous y êtes invité, activez .xml for Android (.xml pour Android), puis cliquez sur Download file (Télécharger le fichier).

4. Enregistrez le fichier dans le répertoire des 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 = {
  template_id: 'my-first-template-v1-0-0',
};

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 {
  "template_id": "my-first-template-v1-0-0"
});

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>() {
    { "template_id", "my-first-template-v1-0-0" }
  }
);

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 Remote Config modèle 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. Recherchez 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 extraire et activer la configuration, et attribuer la valeur extraite à la constante templateID.

   // 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 templateID = getValue(remoteConfig, 'template_id').asString();
   

Dart

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

// Assign Remote Config values.
String? _templateID = remoteConfig.getString("template_id");

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

 // Add a real-time Remote Config listener
 onConfigUpdate(remoteConfig, {
   next: (configUpdate) => {
      console.log("Updated keys:", configUpdate.getUpdatedKeys());
      if (configUpdate.getUpdatedKeys().has("welcome_message")) {
         activate(remoteConfig).then(() => {
         showWelcomeMessage();
         });
      }
   },
   error: (error) => {
      console.log("Config update error:", error);
   },
   complete: () => {
      console.log("Listening stopped.");
   }
});

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

let templateID = remoteConfig.configValue(forKey: "template_id").stringValue
let model = FirebaseAI.firebaseAI(backend: .googleAI()).templateGenerativeModel()
let customerName = "Jane"

// When making the `generateContent` call, source the template ID value from Remote Config
let response = try await model.generateContent(
  templateID: templateID,
  // Provide the values for any input variables required by your template.
  inputs: [
    "customerName": customerName
  ]
)

// ...

Kotlin

// ...

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).templateGenerativeModel()
val customerName = "Jane"

// When making the `generateContent` call, source the template ID value from Remote Config
val response = model.generateContent(
  remoteConfig.getString("template_id"),
  // Provide the values for any input variables required by your template.
  mapOf(
    "customerName" to customerName
  )
)

val text = response.text
println(text)

Java

// ...

TemplateGenerativeModel ai = FirebaseAI.getInstance()
    .templateGenerativeModel(null /* Request Options */);

TemplateGenerativeModelFutures model = TemplateGenerativeModelFutures.from(ai);
String customerName = "Jane";

// When making the `generateContent` call, source the template ID value from Remote Config
Future<GenerateContentResponse> response = model.generateContent(
    remoteConfig.getString("template_id"),
    // Provide the values for any input variables required by your template.
    mapOf("customerName", customerName)

);
addCallback(response,
      new FutureCallback<GenerateContentResponse>() {
          public void onSuccess(GenerateContentResponse result) {
            System.out.println(result.getText());
          }
          public void onFailure(Throwable t) {
            reportError(t);
          }
    }
executor);

// ...

Web

// ...

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

const model = getTemplateGenerativeModel(ai);
const templateID = getValue(remoteConfig, 'template_id').asString();
const customerName = 'Jane';

// When making the `generateContent` call, source the template ID value from Remote Config
const result = await model.generateContent(
  templateID,
  // Provide the values for any input variables required by your template
  {
    customerName: customerName,
  }
);

// ...

Dart

// ...

final model = FirebaseAI.googleAI().templateGenerativeModel();

final templateID = remoteConfig.getString("template_id");
final customerName = 'Jane';

// When making the `generateContent` call, source the template ID value from Remote Config
var response = await model.generateContent(
  templateID,
  // Provide the values for any input variables required by your template
  inputs: {
    'customerName': customerName,
  },
);

// ...

Unity

// ...

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

var templateID = remoteConfig.GetValue("template_id").StringValue;
var model = ai.GetTemplateGenerativeModel();
var customerName = "Jane";

try
{
    // When making the `generateContent` call, source the template ID value from Remote Config
    var response = await model.GenerateContentAsync(
        templateID,
        // Provide the values for any input variables required by your template
        new Dictionary<string, object>
        {
            { "customerName", customerName },
        }
    );
    Debug.Log($"Response Text: {response.Text}");
}
catch (Exception e)
{
    Debug.LogError($"An error occurred: {e.Message}");
}

// ...