Criar modelos de versão usando a Configuração remota

Swift

Como parte da configuração da Firebase AI Logic, você já adicionou o SDK do Firebase ao app, mas também precisa adicionar a Remote Config.

1. No Xcode, com o projeto aberto, navegue até Arquivo > Adicionar dependências do pacote.

2. Selecione firebase-ios-sdk e clique em Adicionar pacote.

3. No navegador do projeto, selecione seu app > Segmentos > seu app.

4. Na guia Geral, role até Frameworks, bibliotecas e conteúdo incorporado.

5. Clique em +, escolha FirebaseRemoteConfig e clique em Adicionar.

6. Adicione a importação FirebaseRemoteConfig ao seu código:

   import FirebaseRemoteConfig
   

7. Dentro da classe apropriada para seu app, inicialize o Firebase e adicione Remote Config à lógica principal do aplicativo.

   Aqui você vai incluir a Remote Config e o listener de Remote Config em tempo real como importações para que o app possa buscar novos valores em tempo real e adicionar um intervalo mínimo de busca:

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

Kotlin

1. Adicione a dependência da Remote Config ao arquivo Gradle do seu módulo (nível do app) (geralmente app/build.gradle.kts ou 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. Adicione a Remote Config à lógica principal do aplicativo. Aqui você vai inicializar a Remote Config e adicionar um intervalo mínimo de busca:

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

Java

1. Adicione a dependência da Remote Config ao arquivo Gradle do seu módulo (nível do app) (geralmente app/build.gradle.kts ou 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. Adicione a Remote Config à lógica principal do aplicativo. Aqui você vai inicializar a Remote Config e adicionar um intervalo mínimo de busca:

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

Web

1. Abra o código em um editor de texto e importe a Remote Config:

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

2. Na função principal e depois que o app do Firebase for inicializado para o SDK da Firebase AI Logic, inicialize a Remote Config:

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

3. Defina um intervalo de busca mínimo:

   remoteConfig.settings.minimumFetchIntervalMillis = 3600000;
   

Swift

1. No console do Firebase, abra Remote Config.

2. Na guia Parâmetros, abra o Menu e selecione Fazer o download dos valores padrão.

3. Quando solicitado, ative a opção .plist para iOS, e clique em Fazer o download do arquivo.

4. Salve o arquivo no diretório do aplicativo.

5. No Xcode, clique com o botão direito do mouse no app e selecione Adicionar arquivos.

6. Selecione remote_config_defaults.plist e clique em Adicionar.

7. Atualize o código do app para fazer referência ao arquivo padrão:

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

Kotlin

1. No console de Firebase, abra Remote Config.

2. Na guia Parâmetros, abra o Menu e selecione Fazer o download dos valores padrão.

3. Quando solicitado, ative a opção .xml para Android e clique em Fazer o download do arquivo.

4. Salve o arquivo no diretório de recursos XML do app.

5. Atualize o arquivo de atividade principal para adicionar os padrões depois do configSettings adicionado anteriormente:

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

Java

1. No console do Firebase, abra Remote Config.

2. Na guia Parâmetros, abra o Menu e selecione Fazer o download dos valores padrão.

3. Quando solicitado, ative a opção .xml para Android e clique em Fazer o download do arquivo.

4. Salve o arquivo no diretório de recursos XML do app.

5. Atualize o arquivo de atividade principal para adicionar os padrões depois do configSettings adicionado anteriormente:

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

Web

É possível definir o valor padrão para o nome do modelo diretamente no código:

// Set default values for Remote Config parameters.
remoteConfig.defaultConfig = {
  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)")
  }
}

Isso vai atualizar o objeto de Remote Config sempre que um novo modelo de Remote Config for publicado.

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. Adicione getValue e fetchAndActivate às importações:

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

2. Localize o código em que você especifica o valor padrão para o nome do modelo. Imediatamente após esse bloco de código, adicione o seguinte código para buscar e ativar a configuração e atribuir o valor buscado à 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();
   

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

Também é possível configurar uma ação dentro da ativação 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

Também é possível configurar uma ação dentro da ativação 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

Os listeners da Remote Config em tempo real não têm suporte para apps da Web.

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

// ...