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 JavaScript to develop web apps. This guide is framework-independent. 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 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-1.5-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 the Remote Config SDK

Add and initialize the Remote Config SDK:

  1. Open your code in a text editor and import Remote Config:

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

  2. Inside your primary function and after the Firebase app is initialized for Vertex AI in Firebase SDK, initialize Remote Config:

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

  3. Set a minimum fetch interval. 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.

    remoteConfig.settings.minimumFetchIntervalMillis = 3600000;

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.

In this example, you manually set default values for model name, system instructions, user prompt, and Vertex AI location:

// Set default Remote Config parameter values
remoteConfig.defaultConfig = {
  model_name: 'gemini-1.5-flash',
  system_instructions:
    'You are a helpful assistant who knows everything there is to know about Firebase!',
  prompt: 'I am a developer who wants to know more about Firebase!',
  vertex_location: 'us-central1',
};

Step 4: Fetch and activate values

  1. Add getValue and fetchAndActivate to your imports:

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

  2. After the code you added to configure default Remote Config values, fetch and activate the config, then assign values to the modelName, systemInstructions, prompt, and vertexLocation constants.

    // 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();
const systemInstructions = getValue(remoteConfig, 'system_instructions').asString();
const prompt = getValue(remoteConfig, 'prompt').asString();
const vertexLocation = getValue(remoteConfig, 'vertex_location').asString();

Step 5: Update the Vertex AI calls to use Remote Config values

Now that Remote Config is fully configured, update your code to replace hard-coded values with values sourced from Remote Config. For example, if you were using the example used in Get started with the Gemini API using the Vertex AI in Firebase SDKs, you'd update it as follows:

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Vertex AI service
// Optionally specify a location in which to run the service and access the model
const vertexAI = getVertexAI(firebaseApp, { location: vertexLocation });

// Initialize the generative model with a model that supports your use case
// Gemini 1.5 models are versatile and can be used with all API capabilities
const model = getGenerativeModel(vertexAI, {
  model: modelName,
  systemInstruction: systemInstruction
});

// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const userPrompt = prompt;

  // To generate text output, call generateContent with the text input
  const result = await model.generateContent(userPrompt);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

Step 6: Run the app

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

Next steps