Mudar remotamente o nome do modelo no app

A disponibilidade de modelos de IA generativa muda com frequência. Novos e melhores modelos são lançados, e os mais antigos e menos eficientes são desativados.

Ao acessar modelos de IA generativa diretamente de um app para dispositivos móveis ou da Web usando Firebase AI Logic, é fundamental configurar o app para acomodar essas mudanças frequentes no modelo. Nem todos os usuários vão atualizar para a versão mais recente do app para começar a usar o modelo que você quer que eles usem.

Com a Firebase Remote Config, é possível atualizar os valores dos parâmetros no app (como o nome de um modelo) de forma dinâmica e remota no console do Firebase, sem precisar lançar uma nova versão do app.

Mudar o nome de um modelo é um caso de uso crítico para usar Remote Config com Firebase AI Logic, mas também é possível usar Remote Config para controlar parâmetros de forma dinâmica e até condicional no app, como configuração de geração de modelo (tokens máximos, temperatura etc.), configurações de segurança, instruções do sistema e dados de comandos.

Este guia descreve como implementar o Remote Config no seu app, especificamente para controlar o nome do modelo usado nele.

Etapa 1: definir o valor do parâmetro no console do Firebase

Crie um modelo de cliente Remote Config e configure um parâmetro model_name e o valor dele para buscar e usar no app.

  1. Abra seu projeto do Firebase no console do Firebase. Em seguida, no menu de navegação, abra Executar e selecione Remote Config.

  2. Verifique se Cliente está selecionado no seletor Cliente/Servidor na parte de cima da página.

  3. Para iniciar um modelo de cliente, clique em Criar configuração ou Adicionar parâmetro se você já usou modelos de cliente.

  4. Defina o parâmetro model_name:

    Nome do parâmetro Descrição Tipo Valor padrão
    model_name Nome do modelo. Consulte os nomes de modelos disponíveis. String gemini-2.5-flash

  5. Depois de adicionar esse parâmetro, clique em Publicar alterações. Se esse não for um novo modelo de Remote Config, revise as mudanças e clique em Publicar alterações novamente.

Etapa 2: adicionar e inicializar a Remote Config no app

Adicione a biblioteca Remote Config e configure a Remote Config no app.

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;

Dart

  1. No diretório do projeto do Flutter, instale e adicione a Remote Config usando o seguinte comando:

    flutter pub add firebase_remote_config

  2. Abra ./lib/main.dart e adicione a importação depois das outras importações que você adicionou para oferecer suporte à 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. Adicione a variável _modelName ao app para que você possa usá-la mais tarde:

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

  4. Receba a instância de objeto da Remote Config e defina o intervalo mínimo de busca para permitir atualizações frequentes: Adicione isso depois que o Firebase for inicializado.

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

Unity

  1. Adicione Remote Config ao seu projeto do Unity seguindo estas instruções.

  2. Receba a instância de objeto da Remote Config e defina o intervalo mínimo de busca para permitir atualizações frequentes: Adicione isso depois que o Firebase for inicializado.

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

Etapa 3: definir o valor do parâmetro no app

Defina valores de parâmetros padrão no app no objeto Remote Config. Isso garante que o app se comporte como esperado, mesmo que não consiga buscar valores do serviço de Remote Config.

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

Dart

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

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

Unity

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

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

Etapa 4: buscar e ativar o valor

Depois de definir o valor padrão para o nome do modelo, adicione o seguinte para buscar e ativar valores.

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

Etapa 5: adicionar um listener de Remote Config em tempo real

Adicione um listener da Remote Config em tempo real ao app para garantir que as mudanças feitas no modelo da Remote Config sejam propagadas para o cliente assim que forem atualizadas.

O código a seguir atualiza o objeto Remote Config sempre que um valor de parâmetro muda.

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.

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

Etapa 6: atualizar as solicitações da Gemini API para usar o valor da Remote Config

Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página.

Agora que a Remote Config está totalmente configurada, atualize o código para substituir valores codificados por valores provenientes 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
);

// ...

Etapa 7: executar o app

Crie e execute o app e verifique se ele funciona. Faça mudanças na configuração na página de Remote Config do console do Firebase, publique as mudanças e verifique o resultado.

Próximas etapas