Modificare da remoto il nome del modello nell'app

La disponibilità di modelli di AI generativa cambia spesso: vengono rilasciati modelli nuovi e migliori e quelli meno recenti e meno capaci vengono ritirati.

Quando accedi ai modelli di AI generativa direttamente da un'app web o mobile utilizzando Firebase AI Logic, è fondamentale configurare l'app in modo da adattarsi a queste modifiche frequenti del modello. Non tutti gli utenti eseguiranno l'aggiornamento all'ultima versione della tua app per iniziare a utilizzare il modello che vuoi che utilizzino.

Firebase Remote Config ti consente di aggiornare i valori dei parametri nella tua app (ad esempio il nome di un modello) in modo dinamico e da remoto dalla console Firebase, senza dover rilasciare una nuova versione dell'app.

Tieni presente che la modifica del nome di un modello è un caso d'uso critico per l'utilizzo di Remote Config con Firebase AI Logic, ma puoi anche utilizzare Remote Config per controllare in modo dinamico e persino condizionale i parametri della tua app, come la configurazione della generazione del modello (token massimi, temperatura e così via), le impostazioni di sicurezza, le istruzioni di sistema e i dati dei prompt.

Questa guida descrive come implementare Remote Config nella tua app, in particolare per controllare il nome del modello utilizzato nella tua app.

Passaggio 1: imposta il valore del parametro nella console Firebase

Crea un Remote Configmodello client e configura un model_name 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 model_name:

    Nome parametro Descrizione Tipo Valore predefinito
    model_name Nome del modello. Visualizza i nomi dei modelli disponibili. Stringa gemini-2.5-flash

  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;

Dart

  1. Dalla directory del progetto Flutter, installa e aggiungi Remote Config utilizzando il seguente comando:

    flutter pub add firebase_remote_config

  2. Apri ./lib/main.dart e aggiungi l'importazione dopo le altre importazioni che hai aggiunto per supportare 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. Aggiungi la variabile _modelName alla tua app per poterla utilizzare in un secondo momento:

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

  4. Ottieni l'istanza dell'oggetto Remote Config e imposta l'intervallo di recupero minimo per consentire aggiornamenti frequenti. Assicurati di aggiungerlo dopo l'inizializzazione di Firebase.

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

Unity

  1. Aggiungi Remote Config al tuo progetto Unity seguendo queste istruzioni.

  2. Ottieni l'istanza dell'oggetto Remote Config e imposta l'intervallo di recupero minimo per consentire aggiornamenti frequenti. Assicurati di aggiungerlo dopo l'inizializzazione di Firebase.

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

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 = {
  model_name: 'gemini-2.5-flash',
};

Dart

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

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

Unity

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

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

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

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.

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

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

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

// ...

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