Atualize dinamicamente seu app da Vertex AI no Firebase com a Configuração remota do Firebase

Ao chamar a Gemini API do seu app usando um SDK da Vertex AI in Firebase, a solicitação contém vários parâmetros que controlam as respostas da IA generativa. Geralmente, eles incluem o nome do modelo, a 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.

Na maioria dos casos, convém mudar esses valores conforme necessário em vários cenários:

  • Atualize seu modelo de IA generativa sem lançar um novo app. É possível fazer upgrade para versões de modelo mais recentes e estáveis antes que as versões anteriores sejam desativadas, mudar para modelos de menor custo ou de maior desempenho com base nas necessidades e nos atributos dos usuários ou implantar condicionalmente os modelos mais recentes e melhores em segmentos de usuários específicos (como testadores Beta).
  • Defina o local em que você acessa o modelo para que ele fique mais próximo dos usuários.
  • Faça testes A/B de diferentes instruções e comandos do sistema e depois lance aos poucos os valores do experimento vencedor para os usuários.
  • Use flags de recurso para expor ou ocultar rapidamente recursos de IA generativa no app.

A Firebase Remote Config faz tudo isso e mais ainda, permitindo que você atualize os valores dos parâmetros conforme necessário e condicionalmente para instâncias de apps que correspondem às características definidas no console do Firebase, sem lançar uma nova versão do app.

Este guia de soluções apresenta casos de uso recomendados específicos e descreve como adicionar a Remote Config ao seu app de IA generativa.

Ir para a implementação do código

Por que usar a Firebase Remote Config com seu app?

Com a Firebase Remote Config, você ajusta dinamicamente o comportamento do app sem precisar de atualizações. Isso é especialmente útil para apps que usam IA generativa, em que a iteração rápida e o ajuste fino são cruciais.

Casos de uso essenciais para a Remote Config com apps de IA generativa

Recomendamos o uso da Remote Config com a Vertex AI in Firebase para os seguintes casos de uso essenciais:

  • Upgrade para a versão mais recente do modelo sem uma atualização do app: use os parâmetros da Remote Config para mudar o nome do modelo conforme necessário, para que você possa fazer upgrade para a versão mais recente do seu modelo preferido do Gemini assim que ela estiver disponível.
  • Atualizar as instruções do sistema e as configurações de segurança sem atualizar o app: armazene as instruções do sistema e as configurações de segurança nos parâmetros da Remote Config para que elas possam ser alteradas sob demanda se você descobrir problemas após a implantação.
  • Reduzir riscos e aplicar a segurança da IA: use os lançamentos da Remote Config para lançar mudanças de IA generativa de forma segura e gradual para seus usuários do iOS e do Android.

Casos de uso avançados e recomendados para a Remote Config com apps de IA generativa

Depois de instrumentar o app com a Remote Config e o Google Analytics, você pode explorar casos de uso avançados:

  • Defina a localização com base na localização do cliente: use condições de Remote Config para definir a localização do modelo com base na localização detectada do cliente.
  • Teste modelos diferentes: teste e alterne rapidamente entre vários modelos de IA generativa ou implante modelos diferentes em diferentes segmentos de usuários para encontrar o melhor para seu caso de uso específico.
  • Otimize o desempenho do modelo: faça o ajuste fino dos parâmetros do modelo, como comando do sistema, máximo de tokens de saída, temperatura e outras configurações.

  • Use diferentes instruções, comandos e configurações de modelo do sistema com base nos atributos do cliente: ao usar a Remote Config com o Google Analytics, é possível criar condições baseadas nos atributos do cliente ou nos públicos-alvo personalizados e definir diferentes parâmetros com base nesses atributos.

    Por exemplo, se você estiver usando a IA generativa para oferecer suporte técnico no app, defina instruções específicas do sistema para a plataforma do app para garantir que instruções precisas sejam fornecidas aos usuários do Android, iOS e da plataforma da Web.

  • Personalize as experiências para cada usuário: use a personalização da Remote Config para determinar automaticamente as configurações de IA generativa ideais para cada usuário.

  • Controle de custos: ajuste remotamente quais modelos de IA generativa são chamados, com que frequência eles são usados e configure dinamicamente os valores máximos de token de saída com base no público-alvo do usuário para reduzir custos desnecessários.

  • Otimize a experiência e os resultados do app: use A/B Testing com a Remote Config com seus apps iOS, Android e Flutter para testar mudanças nos parâmetros de IA generativa em diferentes segmentos de usuários e conferir como elas afetam as principais métricas, como retenção e receita.

Ao instrumentar seu app de IA generativa com a Firebase Remote Config, você pode criar aplicativos com IA flexíveis, seguros e econômicos, além de criar experiências incríveis para seus usuários.

Adicionar o Firebase Remote Config ao app

Neste guia de solução, você vai usar a Firebase Remote Config para atualizar dinamicamente parâmetros no app Android que usam o SDK da Vertex AI in Firebase. Você aprenderá o seguinte:

  • Buscar e ativar parâmetros como nomes de modelos e instruções do sistema na Firebase Remote Config.
  • Atualizar suas chamadas da Gemini API para usar os parâmetros recuperados dinamicamente, permitindo alternar entre modelos diferentes ou modificar instruções do sistema sem uma atualização do app.
  • Controlar os parâmetros remotamente, ajustando o comportamento e os recursos do modelo conforme necessário.

Pré-requisitos

Neste guia, pressupomos que você já sabe usar o Android Studio para desenvolver apps para plataformas Android. Antes de começar, verifique se você já:

  • Concluiu o Guia para iniciantes do SDK da Vertex AI in Firebase. Verifique se você fez o seguinte:

    1. Configurou um projeto novo ou existente do Firebase, incluindo o uso do plano de preços Blaze e a ativação das APIs necessárias.
    2. Conectou seu app ao Firebase, incluindo o registro e a adição da configuração do Firebase.
    3. Adicionou o SDK e inicializou o serviço da Vertex AI e o modelo generativo no seu app.

  • Ative o Google Analytics no seu projeto e adicione o SDK ao app (obrigatório para segmentação condicional, como definir a localização do serviço e do modelo com base na localização do dispositivo do cliente).

Etapa 1: definir valores de parâmetro no console do Firebase

Crie um modelo de Remote Config do cliente e configure os parâmetros e valores para buscar e usar no app.

  1. Abra seu projeto do Firebase no console do Firebase e, 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 de Remote Config.
    • Se esta é a primeira vez que você usa modelos de Remote Config do cliente, clique em Criar configuração. O painel Criar seu primeiro parâmetro será exibido.
    • Se esta não for a primeira vez que você usa modelos de Remote Config, clique em Adicionar parâmetro.

  3. Defina os seguintes parâmetros Remote Config:

    Nome do parâmetro Descrição Tipo Valor padrão
    model_name Nome do modelo. Para acessar listas atualizadas de nomes de modelos a serem usados no código, consulte Nomes de modelos disponíveis. String gemini-1.5-flash
    system_instructions As instruções do sistema são como um "preâmbulo" que você adiciona antes que o modelo seja exposto a outras instruções do usuário final para influenciar o comportamento do modelo com base em necessidades e casos de uso específicos. String You are a helpful assistant who knows everything there is to know about Firebase!
    prompt Comando padrão para usar com seu recurso de IA generativa. String I am a developer who wants to know more about Firebase!
    vertex_location Controle o local para executar o serviço da Vertex AI e acessar um modelo. É possível definir condições para configurar essa opção com base na localização do cliente detectada pelo Google Analytics. String us-central1

  4. Quando terminar de adicionar parâmetros, 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 o SDK da Remote Config no app

Adicione dependências de Remote Config e configure a Remote Config no app.

  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:33.7.0"))
    implementation("com.google.firebase:firebase-vertexai")
    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:

    Kotlin 

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

Nesse exemplo, o intervalo de busca padrão é de 3.600 segundos, mas recomendamos definir um intervalo de busca mínimo relativamente baixo no código durante o desenvolvimento.

Etapa 3: definir os valores de parâmetros padrão 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.

  1. No console do Firebase, abra a 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:

    Kotlin 

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

    Java 

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

Etapa 4: buscar e ativar valores

Depois de definir padrões, adicione o seguinte para buscar e ativar valores:

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

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

Adicione um listener de 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. Também é possível configurar uma ação dentro da ativação addOnCompleteListener:

Kotlin 

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

Etapa 6: atribuir valores da Remote Config a variáveis da Vertex AI

Agora que a Remote Config está totalmente configurada, atualize o código para substituir valores codificados por valores provenientes da Remote Config.

Substitua os valores codificados para local, nome do modelo, instruções do sistema e comando do usuário pelos valores provenientes da Remote Config.

Kotlin 

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

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 no console do Firebase, publique as mudanças e verifique o resultado.

Próximas etapas