Atualizar dinamicamente a Vertex AI no app do Firebase com a Configuração remota do Firebase

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

Na maioria dos casos, é recomendável mudar esses valores conforme necessário para 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, em seguida, implemente aos poucos os valores do experimento vencedor para os usuários.
  • Use flags de recursos para expor ou ocultar rapidamente recursos de IA generativa no app.

O 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 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 Remote Config ao seu app de IA generativa.

Ir para a implementação do código

Por que usar Firebase Remote Config com seu app?

O Firebase Remote Config permite ajustar 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 Remote Config com apps de IA generativa

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

  • Faça upgrade para a versão mais recente do modelo sem uma atualização do app:use os parâmetros Remote Config para mudar o nome do modelo conforme necessário, para que você possa fazer upgrade para a versão mais recente do modelo Gemini preferido assim que ela estiver disponível.
  • Atualize 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 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 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 Remote Config com apps de IA generativa

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

  • Definir a localização com base na localização do cliente:use condições 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.
  • Otimizar a performance do modelo: 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 com base nos atributos do cliente:ao usar Remote Config com Google Analytics, é possível criar condições com base 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 do sistema específicas 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 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 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 Firebase Remote Config, você pode criar aplicativos com tecnologia de 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 Firebase Remote Config para atualizar dinamicamente parâmetros no app Android que usam o SDK Vertex AI in Firebase. Você aprenderá o seguinte:

  • Buscar e ativar parâmetros como nomes de modelos e instruções do sistema em Firebase Remote Config.
  • Atualize suas chamadas 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.
  • Controle 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ê fez o seguinte:

  • Conclua o Guia de início do SDK Vertex AI in Firebase. Verifique se você fez o seguinte:

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

  • Ative 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 cliente).

Etapa 1: definir valores de parâmetros no console da 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 Firebase e, no menu de navegação, abra Run e selecione Remote Config.
  2. Verifique se Cliente está selecionado no seletor Cliente/Servidor na parte de cima da página Remote Config.
    • Se esta é a primeira vez que você usa modelos de cliente Remote Config, clique em Criar configuração. O painel Criar seu primeiro parâmetro é exibido.
    • Se esta não for a primeira vez que você usa modelos 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 para usar 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 o 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 Vertex AI e acessar um modelo. É possível definir condições para configurar essa opção com base na localização do cliente detectada por 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 Remote Config, revise as mudanças e clique em Publicar alterações novamente.

Etapa 2: adicionar e inicializar o SDK do Remote Config no app

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

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

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

Neste 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 valores de parâmetros 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 Remote Config.

  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 após o configSettings adicionado anteriormente:

    Kotlin+KTX 

    // 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 os padrões, adicione o seguinte para buscar e ativar valores:

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

Etapa 5:adicione um listener 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 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+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);
      }
  });

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

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

Substitua os valores fixados no código para local, nome do modelo, instruções do sistema e solicitação do usuário pelos valores provenientes de 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);

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

Próximas etapas