Aggiornare dinamicamente Vertex AI nell'app Firebase con Firebase Remote Config

Quando chiami Gemini API dalla tua app utilizzando un SDK Vertex AI in Firebase, la richiesta contiene una serie di parametri che controllano le risposte dell'IA generativa. Di solito includono il nome del modello, la configurazione di generazione del modello (token massimi, temperatura e così via), le impostazioni di sicurezza, le istruzioni di sistema e i dati del prompt.

Nella maggior parte dei casi, ti consigliamo di modificarli on demand o in base alle esigenze per una serie di scenari:

  • Aggiorna il tuo modello di IA generativa senza rilasciare una nuova app. Puoi eseguire l'upgrade a versioni di modelli più recenti e stabili prima che quelle precedenti vengano ritirate, passare a modelli a basso costo o con prestazioni più elevate in base alle esigenze e agli attributi dei tuoi utenti oppure implementare in modo condizionale i modelli più recenti e avanzati in segmenti di utenti specifici (come i beta tester).
  • Imposta la posizione da cui accedi al modello in modo che sia più vicina ai tuoi utenti.
  • Esegui test A/B su istruzioni e prompt di sistema diversi, quindi implementa gradualmente i valori dell'esperimento vincente per i tuoi utenti.
  • Utilizza i flag delle funzionalità per mostrare o nascondere rapidamente le funzionalità di IA generativa nella tua app.

Firebase Remote Config fa tutto questo e altro ancora, consentendoti di aggiornare i valori dei parametri in base alle esigenze e in modo condizionale per le istanze dell'app che corrispondono alle caratteristiche impostate nella console Firebase, senza rilasciare una nuova versione dell'app.

Questa guida alla soluzione fornisce casi d'uso consigliati specifici e descrive come aggiungere Remote Config alla tua app di IA generativa.

Vai all'implementazione del codice

Perché utilizzare Firebase Remote Config con la tua app?

Firebase Remote Config ti consente di modificare dinamicamente il comportamento della tua app senza richiedere aggiornamenti dell'app. Questo è particolarmente utile per le app che utilizzano l'IA generativa, in cui l'iterazione rapida e la messa a punto sono fondamentali.

Casi d'uso essenziali per Remote Config con app di IA generativa

Ti consigliamo di utilizzare Remote Config con Vertex AI in Firebase per i seguenti casi d'uso essenziali:

  • Esegui l'upgrade alla versione più recente del modello senza un aggiornamento dell'app: utilizza i parametri Remote Config per modificare il nome del modello in base alle esigenze, in modo da poter eseguire l'upgrade alla versione più recente del tuo preferito Gemini modello non appena sarà disponibile.
  • Aggiorna le istruzioni di sistema e le impostazioni di sicurezza senza un aggiornamento dell'app: memorizza le istruzioni di sistema e le impostazioni di sicurezza all'interno dei parametri Remote Config per assicurarti di poterle modificare in base alle esigenze se riscontri problemi dopo il deployment.
  • Riduci i rischi e applica la sicurezza dell'IA: utilizza le Remote Configimplementazioni per rilasciare in modo sicuro e graduale le modifiche dell'IA generativa agli utenti iOS e Android.

Casi d'uso avanzati e consigliati per Remote Config con app di IA generativa

Dopo aver strumentato l'app con Remote Config e Google Analytics, puoi esplorare casi d'uso avanzati:

  • Imposta la posizione in base alla posizione del client: utilizza le condizioni Remote Config per impostare la posizione del modello in base alla posizione rilevata del client.
  • Sperimenta con diversi modelli: testa e passa rapidamente da un modello di AI generativa all'altro o esegui il deployment di modelli diversi in segmenti di utenti diversi per trovare la soluzione più adatta al tuo caso d'uso specifico.
  • Ottimizzare le prestazioni del modello: perfeziona i parametri del modello, come prompt del sistema, token di output massimi, temperatura e altre impostazioni.

  • Utilizza istruzioni di sistema, prompt e configurazione del modello diversi in base agli attributi del cliente: quando utilizzi Remote Config con Google Analytics, puoi creare condizioni in base agli attributi del cliente o ai segmenti di pubblico personalizzati e impostare parametri diversi in base a questi attributi.

    Ad esempio, se utilizzi l'IA generativa per fornire assistenza tecnica nella tua app, ti consigliamo di impostare istruzioni di sistema specifiche per la piattaforma dell'app per assicurarti che vengano fornite istruzioni accurate agli utenti delle piattaforme Android, iOS e web.

  • Personalizza le esperienze per ogni utente:utilizza la Remote Config personalizzazione per determinare automaticamente le impostazioni di IA generativa ottimali per ogni utente.

  • Controlla i costi: regola da remoto i modelli di IA generativa richiamati, la frequenza con cui vengono utilizzati e configura dinamicamente i valori dei token di output massimi in base al pubblico dell'utente per ridurre i costi non necessari.

  • Ottimizza l'esperienza e i risultati dell'app: utilizza A/B Testing con Remote Config con le tue app per iOS, Android e Flutter per testare le modifiche ai parametri dell'IA generativa in diversi segmenti di utenti per vedere in che modo influiscono su metriche chiave come la fidelizzazione e le entrate.

Se esegui l'instrumentazione della tua app di IA generativa con Firebase Remote Config, puoi creare applicazioni basate sull'IA flessibili, sicure ed economicamente vantaggiose, nonché esperienze piacevoli per i tuoi utenti.

Aggiungere Firebase Remote Config all'app

In questa guida alla soluzione, utilizzerai Firebase Remote Config per aggiornare dinamicamente i parametri nella tua app per Android che utilizzano l'SDK Vertex AI in Firebase. Imparerai come:

  • Recupera e attiva parametri come i nomi dei modelli e le istruzioni di sistema da Firebase Remote Config.
  • Aggiorna le chiamate Gemini API per utilizzare i parametri recuperati dinamicamente, in modo da passare da un modello all'altro o modificare le istruzioni di sistema senza un aggiornamento dell'app.
  • Controlla i parametri da remoto, regolando il comportamento e le funzionalità del modello in base alle esigenze.

Prerequisiti

Questa guida presuppone che tu abbia dimestichezza con l'utilizzo di Android Studio per sviluppare app per le piattaforme Android. Prima di iniziare, assicurati di:

  • Completa la guida introduttiva per l'SDK Vertex AI in Firebase. Assicurati di aver eseguito tutte le seguenti operazioni:

    1. Configura un progetto Firebase nuovo o esistente, ad esempio utilizzando il piano di prezzi Blaze e attivando le API richieste.
    2. Collega la tua app a Firebase, inclusa la registrazione e l'aggiunta della configurazione Firebase.
    3. Aggiungi l'SDK e inizializza il servizio Vertex AI e il modello generativo nella tua app.

  • Attiva Google Analytics nel tuo progetto e aggiungi il relativo SDK alla tua app (obbligatorio per il targeting condizionale, come l'impostazione della posizione del servizio e del modello in base alla posizione del dispositivo client).

Passaggio 1: imposta i valori dei parametri nella console Firebase

Crea un modello Remote Config client e configura i parametri e i valori da recuperare e utilizzare nell'app.

  1. Apri il progetto Firebase nella console Firebase e, nel menu di navigazione, espandi Esegui e seleziona Remote Config.
  2. Assicurati che Client sia selezionato nel selettore Client/Server nella parte superiore della pagina Remote Config.
    • Se è la prima volta che utilizzi i modelli di client Remote Config, fai clic su Crea configurazione. Viene visualizzato il riquadro Crea il tuo primo parametro.
    • Se non è la prima volta che utilizzi i modelli Remote Config, fai clic su Aggiungi parametro.

  3. Definisci i seguenti parametri Remote Config:

    Nome parametro Descrizione Tipo Valore predefinito
    model_name Nome del modello. Per elenchi aggiornati dei nomi dei modelli da utilizzare nel codice, consulta Nomi dei modelli disponibili. Stringa gemini-1.5-flash
    system_instructions Le istruzioni di sistema sono come un "preambolo" che aggiungi prima che il modello venga esposto ad altre istruzioni dell'utente finale per influenzarne il comportamento, in base a esigenze e casi d'uso specifici. Stringa You are a helpful assistant who knows everything there is to know about Firebase!
    prompt Prompt predefinito da utilizzare con la funzionalità di IA generativa. Stringa I am a developer who wants to know more about Firebase!
    vertex_location Se vuoi, controlla la posizione per eseguire il servizio Vertex AI e accedere a un modello. Puoi impostare condizioni per configurare questa opzione in base alla posizione del cliente rilevata da Google Analytics. Stringa us-central1

  4. Al termine dell'aggiunta dei parametri, fai clic su Pubblica modifiche. Se non si tratta di un nuovo modello Remote Config, rivedi le modifiche e fai di nuovo clic su Pubblica modifiche.

Passaggio 2: aggiungi e inizializza l'SDK Remote Config nella tua app

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

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

    dependencies {
    implementation(platform("com.google.firebase:firebase-bom:33.6.0"))
    implementation("com.google.firebase:firebase-vertexai")
    implementation("com.google.firebase:firebase-config")
    // ... other dependencies
}

  2. Aggiungi Remote Config alla logica di applicazione principale. Qui, inizierai Remote Config e aggiungerai un intervallo di recupero minimo:

    Kotlin+KTX 

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

    Java 

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

In questo esempio, l'intervallo di recupero predefinito è 3600 secondi, ma ti consigliamo di impostare un intervallo di recupero minimo relativamente basso nel codice durante lo sviluppo.

Passaggio 3: imposta i valori dei parametri in-app

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

  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 il configSettingsaggiunto in precedenza:

    Kotlin+KTX 

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

    Java 

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

Passaggio 4: recupera e attiva i valori

Dopo aver impostato i valori predefiniti, aggiungi quanto segue per recuperare e attivare i valori:

Kotlin+KTX 

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

Passaggio 5: aggiungi un listener Remote Config in tempo reale

Aggiungi un ascoltatore 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. Facoltativamente, puoi anche configurare un'azione all'interno dell'attivazione addOnCompleteListener:

Kotlin+KTX 

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

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

Passaggio 6: assegna i valori Remote Config alle variabili Vertex AI

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

Sostituisci i valori hardcoded per posizione, nome del modello, istruzioni di sistema e richiesta all'utente con i valori ricavati da Remote Config.

Kotlin+KTX 

// Initialize FirebaseVertexAI instance
// Optionally specify a location in which to run the service and access the model
val vertexAI = Firebase.vertexAI(location = remoteConfig.getString("vertex_location"))

// Initialize the Vertex AI service and the generative model
// Specify a model that supports system instructions, like a Gemini 1.5 model
val generativeModel = Firebase.vertexAI.generativeModel(
  modelName = remoteConfig.getString("model_name"),
  systemInstruction = content { text(remoteConfig.getString("system_instructions")) }
)

// To generate text output, call generateContent with the text input
val response = generativeModel.generateContent(remoteConfig.getString("prompt"))
print(response.text)

Java 

// Initialize FirebaseVertexAI instance
// Optionally specify a location in which to run the service and access the model
FirebaseVertexAI vertexAI = FirebaseVertexAI.getInstance(remoteConfig.getString("vertex_location"));

// Initialize the Vertex AI service and the generative model
// Specify a model that supports system instructions, like a Gemini 1.5 model
GenerativeModel gm = FirebaseVertexAI.getInstance().generativeModel(
  /* modelName */ remoteConfig.getString("model_name"),
  /* generationConfig (optional) */ null,
  /* safetySettings (optional) */ null,
  /* requestOptions (optional) */ new RequestOptions(),
  /* tools (optional) */ null,
  /* toolsConfig (optional) */ null,
  /* systemInstruction (optional) */ new Content.Builder().addText(remoteConfig.getString("system_instructions")).build()
);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// Provide a prompt that contains text
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);

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, pubblica le modifiche e verifica il risultato.

Passaggi successivi