Modelli di versione che utilizzano Remote Config


Quando utilizzi i modelli di prompt del server, puoi aggiornare i valori all'interno di un determinato modello senza rilasciare una nuova versione dell'app. Tuttavia, poiché qualsiasi modifica al modello verrà utilizzata quasi immediatamente dalle richieste della tua app, devi prestare attenzione a non apportare modifiche che potrebbero danneggiare l'app o causare cambiamenti imprevisti nel comportamento.

Pertanto, se vuoi apportare modifiche più sostanziali o implementarle gradualmente, non devi modificare il modello utilizzato nel codice di produzione.

Ti consigliamo invece di utilizzare Firebase Remote Config per controllare il valore dell'ID modello utilizzato nella richiesta al modello.

Firebase Remote Config ti consente di aggiornare i valori dei parametri nella tua app (come l'ID modello) in modo dinamico e da remoto dalla console Firebase, senza dover rilasciare una nuova versione dell'app. Dispone inoltre di funzionalità e integrazioni semplificate per l'implementazione delle modifiche e per i test A/B.

Questa guida descrive come implementare Remote Config nella tua app, in particolare per controllare l'ID modello utilizzato nella tua app.

Passaggio 1: imposta il valore del parametro nella console Firebase

Crea un Remote Configmodello client e configura un template_id parametro e il relativo valore da recuperare e utilizzare nell'app.

  1. Apri il progetto Firebase nella console Firebase. Poi, dal menu di navigazione, espandi Esegui e seleziona Remote Config.

  2. Assicurati che Client sia selezionato nel selettore Client/Server nella parte superiore della pagina.

  3. Inizia un modello di cliente facendo clic su Crea configurazione (o Aggiungi parametro se hai già utilizzato i modelli di cliente).

  4. Definisci il parametro template_id:

    Nome parametro Descrizione Tipo Valore predefinito
    template_id ID modello. Stringa my-first-template-v1-0-0

  5. Dopo aver aggiunto questo parametro, fai clic su Pubblica modifiche. Se questo non è un nuovo modello Remote Config, rivedi le modifiche e fai di nuovo clic su Pubblica modifiche.

Passaggio 2: aggiungi e inizializza Remote Config nella tua app

Aggiungi la libreria Remote Config e configura Remote Config all'interno della tua app.

Swift

Nell'ambito della Firebase AI Logicconfigurazione, hai già aggiunto l'SDK Firebase alla tua app, ma dovrai anche aggiungere Remote Config.

  1. In Xcode, con il progetto aperto, vai a File > Add Package Dependencies (File > Aggiungi dipendenze pacchetto).

  2. Seleziona firebase-ios-sdk e poi fai clic su Aggiungi pacchetto.

  3. Nel navigatore del progetto, seleziona la tua app > Targets (Target) > la tua app.

  4. Nella scheda Generali, scorri fino a Framework, librerie e contenuti incorporati.

  5. Fai clic su + e scegli FirebaseRemoteConfig, poi fai clic su Aggiungi.

  6. Aggiungi l'importazione FirebaseRemoteConfig al codice:

    import FirebaseRemoteConfig

  7. All'interno della classe appropriata per la tua app, inizializza Firebase e aggiungi Remote Config alla logica dell'applicazione principale.

    Qui includerai Remote Config e il Remote Config listener in tempo reale come importazioni in modo che l'app possa recuperare nuovi valori in tempo reale e aggiungere un intervallo di recupero minimo:

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

Kotlin

  1. Aggiungi la dipendenza Remote Config al file Gradle del modulo (a livello di app) (solitamente app/build.gradle.kts o app/build.gradle):

    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. Aggiungi Remote Config alla logica principale dell'applicazione. Qui inizializzerai Remote Config e aggiungerai un intervallo di recupero minimo:

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

Java

  1. Aggiungi la dipendenza Remote Config al file Gradle del modulo (a livello di app) (solitamente app/build.gradle.kts o app/build.gradle):

    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. Aggiungi Remote Config alla logica principale dell'applicazione. Qui inizializzerai Remote Config e aggiungerai un intervallo di recupero minimo:

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

Web

  1. Apri il codice in un editor di testo e importa Remote Config:

    import { getRemoteConfig } from 'firebase/remote-config';

  2. All'interno della funzione principale e dopo l'inizializzazione dell'app Firebase per l'SDK Firebase AI Logic, inizializza Remote Config:

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

  3. Imposta un intervallo di recupero minimo:

    remoteConfig.settings.minimumFetchIntervalMillis = 3600000;

Passaggio 3: imposta il valore del parametro in-app

Devi impostare i valori predefiniti dei parametri in-app nell'oggetto Remote Config. In questo modo, la tua app si comporta come previsto anche se non può recuperare i valori dal servizio Remote Config.

Swift

  1. Nella console Firebase, apri Remote Config.

  2. Nella scheda Parametri, apri il menu e seleziona Scarica valori predefiniti.

  3. Quando richiesto, attiva .plist per iOS, quindi fai clic su Scarica file.

  4. Salva il file nella directory dell'applicazione.

  5. In Xcode, fai clic con il tasto destro del mouse sull'app e seleziona Aggiungi file.

  6. Seleziona remote_config_defaults.plist, poi fai clic su Aggiungi.

  7. Aggiorna il codice dell'app in modo che faccia riferimento al file predefinito:

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

Kotlin

  1. Dalla console Firebase, apri Remote Config.

  2. Nella scheda Parametri, apri il menu e seleziona Scarica valori predefiniti.

  3. Quando richiesto, attiva .xml per Android, quindi fai clic su Scarica file.

  4. Salva il file nella directory delle risorse XML dell'app.

  5. Aggiorna il file dell'attività principale per aggiungere i valori predefiniti dopo configSettings che hai aggiunto in precedenza:

    // Set default values for Remote Config parameters.
remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

Java

  1. Nella console Firebase, apri Remote Config.

  2. Nella scheda Parametri, apri il menu e seleziona Scarica valori predefiniti.

  3. Quando richiesto, attiva .xml per Android, quindi fai clic su Scarica file.

  4. Salva il file nella directory delle risorse XML dell'app.

  5. Aggiorna il file dell'attività principale per aggiungere i valori predefiniti dopo configSettings che hai aggiunto in precedenza:

    // Set default values for Remote Config parameters.
mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Web

Puoi impostare il valore predefinito per il nome del modello direttamente nel codice:

// Set default values for Remote Config parameters.
remoteConfig.defaultConfig = {
  template_id: 'my-first-template-v1-0-0',
};

Passaggio 4: recupera e attiva il valore

Dopo aver impostato il valore predefinito per il nome del modello, aggiungi quanto segue per recuperare e attivare i valori.

Swift 

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

In questo modo, l'oggetto Remote Config verrà aggiornato ogni volta che viene pubblicato un nuovo modello Remote Config.

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. Aggiungi getValue e fetchAndActivate alle importazioni:

    import { getValue, fetchAndActivate } from 'firebase/remote-config';

  2. Individua il codice in cui specifichi il valore predefinito per il nome del modello. Subito dopo il blocco di codice, aggiungi il codice seguente per recuperare e attivare la configurazione e assegnare il valore recuperato alla costante 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();

Passaggio 5: aggiungi un ascoltatore Remote Config in tempo reale

Aggiungi un listener Remote Config in tempo reale alla tua app per assicurarti che le modifiche apportate al modello Remote Config vengano propagate al client non appena vengono aggiornate.

Il seguente codice aggiorna l'oggetto Remote Config ogni volta che un valore del parametro cambia.

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

Facoltativamente, puoi anche configurare un'azione all'interno dell'attivazione di 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

Facoltativamente, puoi anche configurare un'azione all'interno dell'attivazione di 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

Gli ascoltatori Remote Config in tempo reale non sono supportati per le app web.

Passaggio 6: aggiorna le richieste Gemini API in modo che utilizzino il valore Remote Config

Fai clic sul tuo fornitore Gemini API per visualizzare i contenuti e il codice specifici del fornitore in questa pagina.

Ora che Remote Config è completamente configurato, aggiorna il codice per sostituire i valori hardcoded con i valori provenienti da Remote Config.

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

// ...

Passaggio 7: esegui l'app

Crea ed esegui l'app e verifica che funzioni. Apporta modifiche alla configurazione dalla pagina Remote Config nella console Firebase, pubblicale e verifica il risultato.

Passaggi successivi