Actualiza de forma dinámica tu app de Vertex AI in Firebase con Firebase Remote Config

Cuando llamas a Gemini API desde tu app con un SDK de Vertex AI in Firebase, tu solicitud contiene una serie de parámetros que controlan las respuestas de la IA generativa. Por lo general, incluyen el nombre del modelo, la configuración de generación de modelos (tokens máximos, temperatura, etc.), la configuración de seguridad, las instrucciones del sistema y los datos de instrucciones.

En la mayoría de los casos, querrás cambiarlos según sea necesario o a pedido para una serie de situaciones:

  • Actualiza tu modelo de IA generativa sin lanzar una app nueva. Puedes actualizar a versiones de modelos más recientes y estables antes de que las versiones anteriores se retiren, cambiar a modelos de menor costo o mayor rendimiento según las necesidades y los atributos de tus usuarios, o implementar de forma condicional los modelos más recientes y mejores en segmentos de usuarios específicos (como verificadores beta).
  • Establece la ubicación desde la que accedes al modelo para que esté más cerca de tus usuarios.
  • Realiza pruebas A/B de diferentes instrucciones y mensajes del sistema y, luego, implementa de forma gradual los valores del experimento ganador para tus usuarios.
  • Usa marcas de función para ocultar o exponer rápidamente las funciones potenciadas por IA generativa en tu app.

Firebase Remote Config hace todo esto y mucho más, lo que te permite actualizar los valores de los parámetros según sea necesario y de forma condicional para instancias de apps que coincidan con las características que estableciste en Firebase console, sin lanzar una versión nueva de la app.

En esta guía de solución, se proporcionan casos de uso recomendados específicos y se describe cómo agregar Remote Config a tu app de IA generativa.

Ir a la implementación de código

¿Por qué usar Firebase Remote Config con tu app?

Firebase Remote Config te permite ajustar de forma dinámica el comportamiento de tu app sin necesidad de actualizarla. Esto es especialmente potente para las apps que usan IA generativa, en las que la iteración rápida y el ajuste fino son fundamentales.

Casos de uso esenciales para Remote Config con apps de IA generativa

Recomendamos usar Remote Config con Vertex AI in Firebase para los siguientes casos de uso esenciales:

  • Actualiza a la versión más reciente del modelo sin actualizar la app: Usa los parámetros de Remote Config para cambiar el nombre del modelo según sea necesario, de modo que puedas actualizar a la versión más reciente de tu modelo de Gemini preferido en cuanto esté disponible.
  • Actualiza las instrucciones del sistema y la configuración de seguridad sin actualizar la app: Almacena las instrucciones del sistema y la configuración de seguridad dentro de los parámetros de Remote Config para asegurarte de poder cambiarlos a pedido si descubres problemas después de la implementación.
  • Reduce el riesgo y aplica la seguridad de la IA: Usa los lanzamientos de Remote Config para lanzar cambios de IA generativa de forma segura y gradual a tus usuarios de iOS y Android.

Casos de uso avanzados y recomendados para Remote Config con apps de IA generativa

Después de instrumentar tu app con Remote Config y Google Analytics, puedes explorar casos de uso avanzados:

  • Establece la ubicación según la ubicación del cliente: Usa condiciones de Remote Config para configurar la ubicación del modelo según la ubicación detectada del cliente.
  • Experimenta con diferentes modelos: Prueba y cambia rápidamente entre varios modelos de IA generativa, o incluso implementa diferentes modelos en diferentes segmentos de usuarios, para encontrar el que mejor se adapte a tu caso de uso específico.
  • Optimiza el rendimiento del modelo: Ajusta con precisión los parámetros del modelo, como el mensaje del sistema, la cantidad máxima de tokens de salida, la temperatura y otros parámetros de configuración.

  • Usa diferentes instrucciones del sistema, mensajes y configuraciones de modelos según los atributos del cliente: Cuando usas Remote Config con Google Analytics, puedes crear condiciones según los atributos del cliente o los públicos personalizados y configurar diferentes parámetros según estos atributos.

    Por ejemplo, si usas IA generativa para proporcionar asistencia técnica en tu app, te recomendamos que configures instrucciones del sistema específicas para la plataforma de la app para garantizar que se proporcionen instrucciones precisas a los usuarios de Android, iOS y la plataforma web.

  • Personaliza las experiencias para cada usuario: Usa la personalización de Remote Config para determinar automáticamente la configuración óptima de IA generativa para cada usuario.

  • Controla los costos: Ajusta de forma remota a qué modelos de IA generativa se llama, con qué frecuencia se usan y configura de forma dinámica los valores máximos de tokens de salida según los públicos de usuarios para reducir los costos innecesarios.

  • Optimiza la experiencia y los resultados de la app: Usa A/B Testing con Remote Config en tus apps para iOS, Android y Flutter para probar los cambios en los parámetros de IA generativa en distintos segmentos de usuarios y ver cómo afectan a las métricas clave, como la retención y los ingresos.

Cuando instrumentas tu app de IA generativa con Firebase Remote Config, puedes crear aplicaciones potenciadas por IA flexibles, seguras y rentables, a la vez que creas experiencias encantadoras para tus usuarios.

Agrega Firebase Remote Config a tu app

En esta guía de solución, usarás Firebase Remote Config para actualizar de forma dinámica los parámetros de tu app para Android que usan el SDK de Vertex AI in Firebase. Aprenderás a hacer lo siguiente:

  • Recupera y activa parámetros, como nombres de modelos e instrucciones del sistema, desde Firebase Remote Config.
  • Actualiza tus llamadas a Gemini API para usar los parámetros recuperados de forma dinámica, lo que te permite cambiar entre diferentes modelos o modificar las instrucciones del sistema sin actualizar la app.
  • Controla los parámetros de forma remota y ajusta el comportamiento y las capacidades del modelo según sea necesario.

Requisitos previos

En esta guía, se da por sentado que conoces Android Studio y que lo usas para desarrollar apps para plataformas de Android. Antes de comenzar, asegúrate de haber realizado lo siguiente:

  • Completa la guía de introducción del SDK de Vertex AI in Firebase. Asegúrate de haber hecho lo siguiente:

    1. Configura un proyecto de Firebase nuevo o existente, incluido el uso del plan de precios Blaze y la habilitación de las APIs requeridas.
    2. Conecta tu app a Firebase, lo que incluye registrarla y agregar la configuración de Firebase a la app.
    3. Agrega el SDK y, luego, inicializa el servicio de Vertex AI y el modelo generativo en tu app.

  • Habilita Google Analytics en tu proyecto y agrega su SDK a tu app (obligatorio para la segmentación condicional, como configurar la ubicación del servicio y del modelo según la ubicación del dispositivo cliente).

Paso 1: Configura los valores de los parámetros en Firebase console

Crea una plantilla de Remote Config del cliente y configura los parámetros y valores para recuperarlos y usarlos en la app.

  1. Abre tu proyecto de Firebase en Firebase console y, desde el menú de navegación, expande Ejecutar y selecciona Remote Config.
  2. Asegúrate de que la opción Cliente esté seleccionada en el selector Cliente/Servidor que se encuentra en la parte superior de la página Remote Config.
    • Si es la primera vez que usas plantillas de cliente de Remote Config, haz clic en Crear configuración. Aparecerá el panel Crea tu primer parámetro.
    • Si no es la primera vez que usas plantillas de servidor de Remote Config, haz clic en Agregar parámetro.

  3. Define los siguientes parámetros de Remote Config:

    Nombre del parámetro Descripción Tipo Valor predeterminado
    model_name Nombre del modelo Para obtener listas actualizadas de los nombres de modelos que puedes usar en tu código, consulta Nombres de modelos disponibles. String gemini-1.5-flash
    system_instructions Las instrucciones del sistema son como un "preámbulo" que agregas antes de que el modelo se exponga a otras instrucciones del usuario final para influir en su comportamiento, según necesidades y casos de uso específicos. String You are a helpful assistant who knows everything there is to know about Firebase!
    prompt El mensaje predeterminado que se usará con tu función potenciada por IA generativa. String I am a developer who wants to know more about Firebase!
    vertex_location De manera opcional, controla la ubicación para ejecutar el servicio de Vertex AI y acceder a un modelo. Puedes establecer condiciones para configurar esta opción en función de la ubicación del cliente que detecta Google Analytics. String us-central1

  4. Cuando hayas terminado de agregar los parámetros, haz clic en Publicar cambios. Si esta no es una plantilla de Remote Config nueva, revisa los cambios y vuelve a hacer clic en Publicar cambios.

Paso 2: Agrega y, luego, inicializa el SDK de Remote Config en tu app

Agrega dependencias de Remote Config y configura Remote Config en tu app.

  1. Agrega la dependencia de Remote Config al archivo Gradle del módulo (nivel de app) (generalmente app/build.gradle.kts o 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. Agrega Remote Config a la lógica principal de la aplicación. Aquí, inicializarás Remote Config y agregarás un intervalo de recuperación mínimo:

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

En este ejemplo, el intervalo de recuperación predeterminado es de 3,600 segundos, pero te recomendamos que establezcas un intervalo de recuperación mínimo relativamente bajo en tu código durante el desarrollo.

Paso 3: Configura los valores de los parámetros en la app

Debes establecer los valores de los parámetros predeterminados en la app en el objeto de Remote Config. Esto garantiza que tu app se comporte como se espera, incluso si no puede recuperar valores del servicio de Remote Config.

  1. En Firebase console, abre Remote Config.
  2. En la pestaña Parámetros, abre el menú y selecciona Descargar valores predeterminados.
  3. Cuando se solicite, habilita .xml para Android y haz clic en Descargar archivo.
  4. Guarda el archivo en el directorio de recursos XML de tu app.

  5. Actualiza tu archivo de actividad principal para agregar los valores predeterminados después del configSettings que agregaste anteriormente:

    Kotlin+KTX 

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

    Java 

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

Paso 4: Recupera y activa valores

Después de establecer los valores predeterminados, agrega lo siguiente para recuperar y activar 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)
            }
          }
    });

Paso 5: Agrega un objeto de escucha de Remote Config en tiempo real

Agrega un objeto de escucha de Remote Config en tiempo real a tu app para garantizar que los cambios que realices en la plantilla de Remote Config se propaguen al cliente en cuanto se actualicen.

El siguiente código actualiza el objeto de Remote Config cada vez que cambia el valor de un parámetro. De manera opcional, también puedes configurar una acción dentro de la activación de 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);
      }
  });

Paso 6: Asigna los valores de Remote Config a las variables de Vertex AI

Ahora que Remote Config está completamente configurado, actualiza tu código para reemplazar los valores hard-coded con los valores provenientes de Remote Config.

Reemplaza los valores hard-coded de la ubicación, el nombre del modelo, las instrucciones del sistema y el mensaje del usuario por los valores que provienen 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);

Paso 7: Ejecuta la app

Compila y ejecuta la app, y verifica que funcione. Realiza cambios en la configuración desde la página Remote Config en Firebase console, publica los cambios y verifica el resultado.

Próximos pasos