Dynamically update your Vertex AI in Firebase app with Firebase Remote Config

When calling the Gemini API from your app using a Vertex AI in Firebase SDK, your request contains a number of parameters that control generative AI responses. These usually include the model name, the model generation configuration (maximum tokens, temperature, etc.), safety settings, system instructions, and prompt data.

In most cases, you'll want to change these on-demand or as needed for a number of scenarios:

  • Update your generative AI model without releasing a new app. You can upgrade to newer, stable model versions before earlier versions are decommissioned, drop to lower-cost or higher performance models based on your users' needs and attributes, or conditionally deploy the latest and greatest models to specific user segments (like beta testers).
  • Set the location where you access the model so that it's closer to your users.
  • A/B test different system instructions and prompts, then slowly roll out the winning experiment values to your users.
  • Use feature flags to quickly expose or hide generative AI features in your app.

Firebase Remote Config does all of this and more, letting you update parameter values as needed and conditionally for app instances that match characteristics you set in the Firebase console, without releasing a new version of your app.

This solution guide provides specific recommended use cases and describes how to add Remote Config to your generative AI app.

Jump to code implementation

Why use Firebase Remote Config with your app?

Firebase Remote Config lets you dynamically adjust your app's behavior without requiring app updates. This is especially powerful for apps that use generative AI, where rapid iteration and fine-tuning are crucial.

Essential use cases for Remote Config with generative AI apps

We recommend using Remote Config with Vertex AI in Firebase for the following essential use cases:

  • Upgrade to the latest model version without an app update: Use Remote Config parameters to change the model name as needed, so that you can upgrade to the latest version of your preferred Gemini model as soon as it's available.
  • Update system instructions and safety settings without an app update: Store system instructions and safety settings inside Remote Config parameters to ensure that you can change them on-demand if you discover issues after deployment.
  • Reduce risk and enforce AI safety: Use Remote Config Rollouts to safely and gradually release generative AI changes to your iOS and Android users.

Advanced and recommended use cases for Remote Config with generative AI apps

After instrumenting your app with Remote Config and Google Analytics, you can explore advanced use cases:

  • Set location based on client location: Use Remote Config conditions to set the location of the model based on the client's detected location.
  • Experiment with different models: Quickly test and switch between various generative AI models, or even deploy different models to different user segments, to find the best fit for your specific use case.
  • Optimize model performance: Fine-tune model parameters, such as system prompt, maximum output tokens, temperature, and other settings.
  • Use different system instructions, prompts, and model configuration based on client attributes: When using Remote Config with Google Analytics, you can create conditions based on client attributes or custom audiences and set different parameters based on these attributes.

    For example, if you're using generative AI to provide technical support in your app, you might want to set system instructions specific to the app platform to ensure accurate instructions are provided to your Android, iOS, and web platform users.

  • Personalize experiences for each user: Use Remote Config personalization to automatically determine the optimum generative AI settings for each user.

  • Control costs: Remotely adjust which generative AI models are called, how frequently they are used, and dynamically configure maximum output token values based on user audience to reduce unnecessary costs.

  • Optimize app experience and results: Use A/B Testing with Remote Config with your iOS, Android, and Flutter apps to test changes to generative AI parameters across different user segments to see how they affect key metrics like retention and revenue.

By instrumenting your generative AI app with Firebase Remote Config, you can build flexible, safe, and cost-effective AI-powered applications while creating delightful experiences for your users.

Add Firebase Remote Config to your app

In this solution guide, you'll use Firebase Remote Config to dynamically update parameters in your Android app that use the Vertex AI in Firebase SDK. You will learn how to:

  • Fetch and activate parameters like model names and system instructions from Firebase Remote Config.
  • Update your Gemini API calls to use the dynamically retrieved parameters, letting you switch between different models or modify system instructions without an app update.
  • Control parameters remotely, adjusting model behavior and capabilities as needed.

Prerequisites

This guide assumes that you're familiar with using Xcode to develop apps for Apple platforms (like iOS). Before you begin, make sure that you have done the following:

  • Complete the Get started guide for the Vertex AI in Firebase SDK. Make sure that you've done all of the following:

    1. Set up a new or existing Firebase project, including using the Blaze pricing plan and enabling the required APIs.
    2. Connect your app to Firebase, including registering your app and adding your Firebase config to your app.
    3. Add the SDK and initialize the Vertex AI service and the generative model in your app.
  • Enable Google Analytics in your project and add its SDK to your app (required for conditional targeting, like setting the service and model's location based on the client device's location).

Step 1: Set parameter values in the Firebase console

Create a client Remote Config template and configure parameters and values to fetch and use in the app.

  1. Open your Firebase project in the Firebase console and, from the navigation menu, expand Run and select Remote Config.
  2. Ensure that Client is selected from the Client/Server selector at the top of the Remote Config page.
    • If this is your first time using Remote Config client templates, click Create Configuration. The Create your first parameter pane appears.
    • If this is not your first time using Remote Config templates, click Add parameter.
  3. Define the following Remote Config parameters:

    Parameter name Description Type Default value
    model_name Model name. For up-to-date lists of model names to use in your code, see Available model names. String gemini-2.0-flash
    system_instructions System instructions are like a "preamble" that you add before the model gets exposed to any further instructions from the end user to influence model behavior, based on specific needs and use cases. String You are a helpful assistant who knows everything there is to know about Firebase!
    prompt Default prompt to use with your generative AI feature. String I am a developer who wants to know more about Firebase!
    vertex_location Optionally control the location to run the Vertex AI service and access a model. You can set conditions to configure this option based on client location detected by Google Analytics. String us-central1
  4. When you've finished adding parameters, click Publish changes. If this is not a new Remote Config template, review the changes and click Publish changes again.

Step 2: Add and initialize Remote Config in your app

Add Remote Config dependencies and set up Remote Config within your app. As part of Vertex AI in Firebase setup, you've already added the Firebase SDK to your app, but will also need to add Remote Config.

  1. In Xcode, with the project open, navigate to File > Add Package Dependencies.
  2. Select firebase-ios-sdk and then click Add package.
  3. From the Project navigator, select your app > Targets > your app.
  4. From the General tab, scroll to Frameworks, Libraries, and Embedded Content.
  5. Click + and choose FirebaseRemoteConfig, then click Add.
  6. Add the FirebaseRemoteConfig import to your code:

    import FirebaseRemoteConfig
    
  7. Inside the appropriate class for your app (in the sample app, this would be inside VertexAISampleApp, within the AppDelegate class), initialize Firebase and add Remote Config to your main application logic.

    Here, you'll include Remote Config and the Remote Config real-time listener as imports so that the app can fetch new values in real-time, and add a minimum fetch interval:

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

In this example, the default fetch interval is 3600 seconds, but we recommend that you set a relatively low minimum fetch interval inside your code during development.

Step 3: Set in-app parameter values

You should set in-app default parameter values in the Remote Config object, so that your app is functional before it connects to the Remote Config backend, if client network access is interrupted, and/or if no values are configured on the backend.

  1. From the Firebase console, open Remote Config.
  2. In the Parameters tab, open the Menu, and select Download default values.
  3. When prompted, enable .plist for iOS, then click Download file.
  4. Save the file in the your application directory (if using the sample app, save within FirebaseVertexAI/Sample/VertexAISample).
  5. In Xcode, right-click on your app and select Add Files (if using the sample, right-click on VertexAISample and select Add Files to "VertexAISample").
  6. Select remote_config_defaults.plist, then click Add.
  7. Update your app code to reference the defaults file:

    // Set default values
    remoteConfig.setDefaults(fromPlist: "remote_config_defaults")
    

Step 4: Fetch and activate values

After setting defaults, add the following to fetch and activate values:

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

This should update the Remote Config object whenever a new Remote Config template is published.

Step 5: Add a real-time Remote Config listener

Add a real-time Remote Config listener to ensure that changes you make to the Remote Config template are propagated to the client as soon as they're updated.

The following code updates the Remote Config object whenever a parameter value changes.

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

This should update the Remote Config object whenever a new Remote Config template is published.

Step 6: Assign Remote Config values to Vertex AI variables

Now that Remote Config is fully configured, update your code to replace hard-coded values with values sourced from Remote Config.

Create values to store your model and system prompt values. The following code demonstrates obtaining the location, model name, system instructions, user prompt, and Vertex AI location from Remote Config:

// Initialize the Vertex AI service
// Optionally specify a location in which to run the service and access the model
let vertexLocation = remoteConfig.configValue(forKey: "vertex_location").stringValue
let vertex = VertexAI.vertexAI(location: vertexLocation)

// Initialize the generative model with a model that supports your use case
// Specify a model that supports system instructions, like a Gemini 1.5 model
let modelName = remoteConfig.configValue(forKey: "model_name").stringValue
let systemInstructions = remoteConfig.configValue(forKey: "system_instructions").stringValue

let model = vertex.generativeModel(
  modelName: modelName,
  systemInstruction: ModelContent(role: "system", parts: systemInstructions)
)

// Provide a prompt that contains text
let userPrompt = remoteConfig.configValue(forKey: "prompt").stringValue

// To generate text output, call generateContent with the text input
let response = try await model.generateContent(userPrompt)
if let text = response.text {
  print(text)
}

Step 7: Run the app

Build and run your app and verify that it works. Make changes to your configuration from the Remote Config page in the Firebase console console, publish the changes, and verify the result.

Next steps