Cómo cambiar de forma remota el nombre del modelo en tu app

La disponibilidad de los modelos de IA generativa cambia con frecuencia: se lanzan modelos nuevos y mejores, y se retiran los modelos más antiguos y menos capaces.

Cuando accedes a modelos de IA generativa directamente desde una app web o para dispositivos móviles con Firebase AI Logic, es fundamental que configures tu app para que se adapte a estos cambios frecuentes en los modelos. No todos los usuarios actualizarán la app a la versión más reciente para comenzar a usar el modelo que necesitas que usen.

Firebase Remote Config te permite actualizar los valores de los parámetros en tu app (como el nombre de un modelo) de forma dinámica y remota desde la consola de Firebase, sin necesidad de lanzar una versión nueva de la app.

Ten en cuenta que cambiar el nombre de un modelo es un caso de uso crítico para usar Remote Config con Firebase AI Logic, pero también puedes usar Remote Config para controlar de forma dinámica e incluso condicional los parámetros de tu app, como 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 esta guía, se describe cómo implementar Remote Config en tu app, específicamente para controlar el nombre del modelo que se usa en ella.

Paso 1: Configura el valor del parámetro en la consola de Firebase

Crea una plantilla de cliente Remote Config y configura un parámetro model_name y su valor para recuperarlos y usarlos en la app.

  1. Abre tu proyecto de Firebase en la consola de Firebase. Luego, en 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 .

  3. Para iniciar una plantilla de cliente, haz clic en Crear configuración (o Agregar parámetro si ya usaste plantillas de cliente).

  4. Define el parámetro model_name:

    Nombre del parámetro Descripción Tipo Valor predeterminado
    model_name Nombre del modelo Consulta los nombres de modelos disponibles. String gemini-2.5-flash

  5. Después de agregar este parámetro, 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 Remote Config en tu app

Agrega la biblioteca de Remote Config y configura Remote Config en tu app.

Swift

Como parte de la configuración de Firebase AI Logic, ya agregaste el SDK de Firebase a tu app, pero también deberás agregar Remote Config.

  1. En Xcode, con el proyecto abierto, navega a Archivo > Agregar dependencias de paquetes.

  2. Selecciona firebase-ios-sdk y, luego, haz clic en Agregar paquete.

  3. En el navegador de proyectos, selecciona tu app > Destinos > tu app.

  4. En la pestaña General, desplázate hasta Frameworks, bibliotecas y contenido incorporado.

  5. Haz clic en + y elige FirebaseRemoteConfig. Luego, haz clic en Agregar.

  6. Agrega la importación FirebaseRemoteConfig a tu código:

    import FirebaseRemoteConfig

  7. Dentro de la clase adecuada para tu app, inicializa Firebase y agrega Remote Config a la lógica principal de la aplicación.

    Aquí, incluirás Remote Config y el objeto de escucha en tiempo real de Remote Config como importaciones para que la app pueda recuperar valores nuevos en tiempo real y agregar un intervalo de recuperación mínimo:

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

Kotlin

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

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

Java

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

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

Web

  1. Abre tu código en un editor de texto y, luego, importa Remote Config:

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

  2. Dentro de tu función principal y después de que se inicialice la app de Firebase para el SDK de Firebase AI Logic, inicializa Remote Config:

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

  3. Establece un intervalo de recuperación mínimo:

    remoteConfig.settings.minimumFetchIntervalMillis = 3600000;

Dart

  1. Desde el directorio de tu proyecto de Flutter, instala y agrega Remote Config con el siguiente comando:

    flutter pub add firebase_remote_config

  2. Abre ./lib/main.dart y agrega la importación después de las otras importaciones que agregaste para admitir 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. Agrega la variable _modelName a tu app para que puedas usarla más adelante:

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

  4. Obtén una instancia de objeto de Remote Config y establece el intervalo de recuperación mínimo para permitir actualizaciones frecuentes: Asegúrate de agregar esto después de que se inicialice Firebase.

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

Unity

  1. Agrega Remote Config a tu proyecto de Unity siguiendo estas instrucciones.

  2. Obtén una instancia de objeto de Remote Config y establece el intervalo de recuperación mínimo para permitir actualizaciones frecuentes: Asegúrate de agregar esto después de que se inicialice Firebase.

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

Paso 3: Configura el valor del parámetro 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.

Swift

  1. En la consola de Firebase, abre Remote Config.

  2. En la pestaña Parameters, abre el menú y selecciona Download default values.

  3. Cuando se solicite, habilita .plist para iOS y, luego, haz clic en Descargar archivo.

  4. Guarda el archivo en el directorio de tu aplicación.

  5. En Xcode, haz clic con el botón derecho en tu app y selecciona Agregar archivos.

  6. Selecciona remote_config_defaults.plist y, luego, haz clic en Agregar.

  7. Actualiza el código de tu app para hacer referencia al archivo de valores predeterminados:

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

Kotlin

  1. En Firebase console, abre Remote Config.

  2. En la pestaña Parameters, abre el menú y selecciona Download default values.

  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:

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

Java

  1. En la consola de Firebase, abre Remote Config.

  2. En la pestaña Parameters, abre el menú y selecciona Download default values.

  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:

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

Web

Puedes establecer el valor predeterminado para el nombre del modelo directamente en tu código:

// Set default values for Remote Config parameters.
remoteConfig.defaultConfig = {
  model_name: 'gemini-2.5-flash',
};

Dart

Puedes establecer el valor predeterminado para el nombre del modelo directamente en tu código:

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

Unity

Puedes establecer el valor predeterminado para el nombre del modelo directamente en tu 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" }
  }
);

Paso 4: Recupera y activa el valor

Después de establecer el valor predeterminado para el nombre del modelo, agrega lo siguiente para recuperar y activar valores.

Swift 

// Fetch and activate Remote Config values
remoteConfig.fetchAndActivate { status, error in
  if let error = error {
    print("Error fetching Remote Config: \(error.localizedDescription)")
  }
}

Esto debería actualizar el objeto de Remote Config cada vez que se publique una nueva plantilla Remote Config.

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. Agrega getValue y fetchAndActivate a tus importaciones:

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

  2. Busca el código en el que especificas el valor predeterminado para el nombre del modelo. Inmediatamente después de ese bloque de código, agrega el siguiente código para recuperar y activar la configuración, y asignar el valor recuperado a la 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();

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.

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

De manera opcional, también puedes configurar una acción dentro de la activación de 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

De manera opcional, también puedes configurar una acción dentro de la activación de 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

Los objetos de escucha Remote Config en tiempo real no son compatibles con las apps 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();
};

Paso 6: Actualiza las solicitudes de Gemini API para usar el valor de Remote Config

Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página.

Ahora que Remote Config está completamente configurado, actualiza tu código para reemplazar los valores hard-coded por valores provenientes de 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
);

// ...

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