Gemini 3 Pro & Flash, Gemini 3 Pro Image (nano banana pro), and the latest Gemini Live API native audio models are now available to use with Firebase AI Logic on all platforms!

Version templates using Remote Config

When you use server prompt templates, you can update values within a given template without releasing a new version of your app. However, since any changes to the template will nearly immediately be used by requests from your app, you need to be cautious about making changes that could break your app or cause unexpected changes in behavior.

So, if you want to make more substantial changes or roll out changes gradually, then you won't want to change the template that's used in production code.

Instead, we recommend using Firebase Remote Config to control the value of template ID used in the request to the model.

Firebase Remote Config lets you update parameter values in your app (like the template ID) dynamically and remotely from the Firebase console, without the need to release a new version of your app. It also has streamlined capabilities and integrations for rolling out changes as well as A/B testing.

This guide describes how to implement Remote Config in your app, specifically to control the template ID used in your app .

Step 1: Set the parameter value in the Firebase console

Create a Remote Config client template and configure a template_id parameter and its value to fetch and use in the app.

Open your Firebase project in the Firebase console. Then, from the navigation menu, expand Runand select Remote Config .
Ensure that Clientis selected from the Client/Serverselector at the top of the page.
Start a client template by clicking Create Configuration(or Add parameterif you've previously used client templates).
Define the template_id parameter:

Parameter name Description Type Default value

template_id
Template ID. String my-first-template-v1-0-0
After adding this parameter, click Publish changes. If this is not a new Remote Config template, review the changes and click Publish changesagain.

Parameter name	Description	Type	Default value
`template_id`	Template ID.	String	`my-first-template-v1-0-0`

Step 2: Add and initialize Remote Config in your app

Add the Remote Config library and set up Remote Config within your app.

Swift

As part of Firebase AI Logic setup , you've already added the Firebase SDK to your app, but will also need to add Remote Config .

In Xcode, with the project open, navigate to File > Add Package Dependencies.
Select firebase-ios-sdkand then click Add package.
From the Project navigator, select your app > Targets> your app.
From the Generaltab, scroll to Frameworks, Libraries, and Embedded Content.
Click +and choose FirebaseRemoteConfig, then click Add.
Add the FirebaseRemoteConfig import to your code:
```
  import 
  
 FirebaseRemoteConfig 
 
```
Inside the appropriate class for your app, 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 
 
```
Note: 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.

Kotlin

Add the Remote Config dependency to your module (app-level) Gradle file (usually app/build.gradle.kts or app/build.gradle ):

  dependencies 
  
 { 
  
 implementation 
 ( 
 platform 
 ( 
 "com.google.firebase:firebase-bom:34.7.0" 
 )) 
  
 implementation 
 ( 
 "com.google.firebase:firebase-ai" 
 ) 
  
 implementation 
 ( 
 "com.google.firebase:firebase-config" 
 ) 
  
 // ... other dependencies 
 }

Add Remote Config to your main application logic. Here, you'll initialize Remote Config and add a minimum fetch interval:

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

Java

Add the Remote Config dependency to your module (app-level) Gradle file (usually app/build.gradle.kts or app/build.gradle ):

  dependencies 
  
 { 
  
 implementation 
 ( 
 platform 
 ( 
 "com.google.firebase:firebase-bom:34.7.0" 
 )) 
  
 implementation 
 ( 
 "com.google.firebase:firebase-ai" 
 ) 
  
 implementation 
 ( 
 "com.google.firebase:firebase-config" 
 ) 
  
 // ... other dependencies 
 }

Add Remote Config to your main application logic. Here, you'll initialize Remote Config and add a minimum fetch interval:

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

Web

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

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

Inside your primary function and after the Firebase app is initialized for Firebase AI Logic SDK, initialize Remote Config :

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

Set a minimum fetch interval:
```
  remoteConfig 
 . 
 settings 
 . 
 minimumFetchIntervalMillis 
  
 = 
  
 3600000 
 ; 
 
```
Note: 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.

Dart

From your Flutter project directory, install and add Remote Config using the following command:
```
 flutter  
pub  
add  
firebase_remote_config 
```

Open ./lib/main.dart and add the import after the other imports you added to support 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' 
 ;

Add the _modelName variable to your app so that you can use it later:

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

Get the Remote Config object instance and set the minimum fetch interval to allow for frequent refreshes. Make sure to add this after Firebase is initialized.

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

Unity

Add Remote Config to your Unity project, following these instructions .

Get the Remote Config object instance and set the minimum fetch interval to allow for frequent refreshes. Make sure to add this after Firebase is initialized.

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

Step 3: Set the in-app parameter value

You should set in-app default parameter values in the Remote Config object. This ensures that your app behaves as expected even if it cannot fetch values from the Remote Config service.

Swift

In the Firebase console, open Remote Config .
In the Parameters tab, open the Menu, and select Download default values.
When prompted, enable .plist for iOS, then click Download file.
Save the file in the your application directory.
In Xcode, right-click on your app and select Add Files
Select remote_config_defaults.plist, then click Add.

Update your app code to reference the defaults file:

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

Kotlin

From the Firebase console, open Remote Config .
In the Parameters tab, open the Menu, and select Download default values.
When prompted, enable .xml for Android, then click Download file.
Save the file in your app's XML resources directory.

Update your main activity file to add the defaults after the configSettings you added previously:

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

Java

In the Firebase console, open Remote Config .
In the Parameters tab, open the Menu, and select Download default values.
When prompted, enable .xml for Android, then click Download file.
Save the file in your app's XML resources directory.

Update your main activity file to add the defaults after the configSettings you added previously:

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

Web

You can set the default value for the model name directly in your code:

  // Set default values for Remote Config parameters. 
 remoteConfig 
 . 
 defaultConfig 
  
 = 
  
 { 
  
 template_id 
 : 
  
 'my-first-template-v1-0-0' 
 , 
 };

Dart

You can set the default value for the model name directly in your code:

  // Set default values for Remote Config parameters. 
 remoteConfig 
 . 
 setDefaults 
 ( 
 const 
  
 { 
  
 "template_id" 
 : 
  
 "my-first-template-v1-0-0" 
 });

Unity

You can set the default value for the model name directly in your code:

  // Set default values for Remote Config parameters. 
 await 
  
 remoteConfig 
 . 
 SetDefaultsAsync 
 ( 
  
 new 
  
 System 
 . 
 Collections 
 . 
 Generic 
 . 
 Dictionary<string 
 , 
  
 object 
> () 
  
 { 
  
 { 
  
 "template_id" 
 , 
  
 "my-first-template-v1-0-0" 
  
 } 
  
 } 
 );

Step 4: Fetch and activate the value

After setting the default value for the model name, add the following to fetch and activate values.

Swift

  // 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.

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

Add getValue and fetchAndActivate to your imports:

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

Locate the code where you specify the default value for the model name. Directly after that code block, add the following code to fetch and activate the config and assign the fetched value to the templateID constant.

  // 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 
  
 templateID 
  
 = 
  
 getValue 
 ( 
 remoteConfig 
 , 
  
 'template_id' 
 ). 
 asString 
 ();

Dart

  // Fetch and activate Remote Config. 
 remoteConfig 
 . 
 fetchAndActivate 
 (); 
 // Assign Remote Config values. 
 String 
 ? 
  
 _templateID 
  
 = 
  
 remoteConfig 
 . 
 getString 
 ( 
 "template_id" 
 );

Unity

  // Fetch and activate Remote Config 
values. 
 await 
  
 remoteConfig 
 . 
 FetchAndActivateAsync 
 ();

Step 5: Add a real-time Remote Config listener

Add a real-time Remote Config listener to your app 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.

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

Optionally, you can also configure an action inside the addOnCompleteListener activation:

   
 // 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

Optionally, you can also configure an action inside the addOnCompleteListener activation:

   
 // 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

Real-time Remote Config listeners aren't supported for Web apps.

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

Step 6: Update the Gemini API requests to use the Remote Config value

Click your Gemini API provider to view provider-specific content and code on this page.

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

Swift

  import 
  
 FirebaseAI 
 let 
  
 templateID 
  
 = 
  
 remoteConfig 
 . 
 configValue 
 ( 
 forKey 
 : 
  
 "template_id" 
 ). 
 stringValue 
 let 
  
 model 
  
 = 
  
 FirebaseAI 
 . 
 firebaseAI 
 ( 
 backend 
 : 
  
 . 
 googleAI 
 ()). 
 templateGenerativeModel 
 () 
 let 
  
 customerName 
  
 = 
  
 "Jane" 
 // When making the `generateContent` call, source the template ID value from Remote Config 
 let 
  
 response 
  
 = 
  
 try 
  
 await 
  
 model 
 . 
 generateContent 
 ( 
  
 templateID 
 : 
  
 templateID 
 , 
  
 // Provide the values for any input variables required by your template. 
  
 inputs 
 : 
  
 [ 
  
 "customerName" 
 : 
  
 customerName 
  
 ] 
 ) 
 // ...

Kotlin

  // ... 
 val 
  
 model 
  
 = 
  
 Firebase 
 . 
 ai 
 ( 
 backend 
  
 = 
  
 GenerativeBackend 
 . 
 googleAI 
 ()). 
 templateGenerativeModel 
 () 
 val 
  
 customerName 
  
 = 
  
 "Jane" 
 // When making the `generateContent` call, source the template ID value from Remote Config 
 val 
  
 response 
  
 = 
  
 model 
 . 
 generateContent 
 ( 
  
 remoteConfig 
 . 
 getString 
 ( 
 "template_id" 
 ), 
  
 // Provide the values for any input variables required by your template. 
  
 mapOf 
 ( 
  
 "customerName" 
  
 to 
  
 customerName 
  
 ) 
 ) 
 val 
  
 text 
  
 = 
  
 response 
 . 
 text 
 println 
 ( 
 text 
 )

Java

  // ... 
 TemplateGenerativeModel 
  
 ai 
  
 = 
  
 FirebaseAI 
 . 
 getInstance 
 () 
  
 . 
 templateGenerativeModel 
 ( 
 null 
  
 /* Request Options */ 
 ); 
 TemplateGenerativeModelFutures 
  
 model 
  
 = 
  
 TemplateGenerativeModelFutures 
 . 
 from 
 ( 
 ai 
 ); 
 String 
  
 customerName 
  
 = 
  
 "Jane" 
 ; 
 // When making the `generateContent` call, source the template ID value from Remote Config 
 Future<GenerateContentResponse> 
  
 response 
  
 = 
  
 model 
 . 
 generateContent 
 ( 
  
 remoteConfig 
 . 
 getString 
 ( 
 "template_id" 
 ), 
  
 // Provide the values for any input variables required by your template. 
  
 mapOf 
 ( 
 "customerName" 
 , 
  
 customerName 
 ) 
 ); 
 addCallback 
 ( 
 response 
 , 
  
 new 
  
 FutureCallback<GenerateContentResponse> 
 () 
  
 { 
  
 public 
  
 void 
  
 onSuccess 
 ( 
 GenerateContentResponse 
  
 result 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 result 
 . 
 getText 
 ()); 
  
 } 
  
 public 
  
 void 
  
 onFailure 
 ( 
 Throwable 
  
 t 
 ) 
  
 { 
  
 reportError 
 ( 
 t 
 ); 
  
 } 
  
 } 
 executor 
 ); 
 // ...

Web

  // ... 
 const 
  
 ai 
  
 = 
  
 getAI 
 ( 
 firebaseApp 
 , 
  
 { 
  
 backend 
 : 
  
 new 
  
 GoogleAIBackend 
 () 
  
 }); 
 const 
  
 model 
  
 = 
  
 getTemplateGenerativeModel 
 ( 
 ai 
 ); 
 const 
  
 templateID 
  
 = 
  
 getValue 
 ( 
 remoteConfig 
 , 
  
 'template_id' 
 ). 
 asString 
 (); 
 const 
  
 customerName 
  
 = 
  
 'Jane' 
 ; 
 // When making the `generateContent` call, source the template ID value from Remote Config 
 const 
  
 result 
  
 = 
  
 await 
  
 model 
 . 
 generateContent 
 ( 
  
 templateID 
 , 
  
 // Provide the values for any input variables required by your template 
  
 { 
  
 customerName 
 : 
  
 customerName 
 , 
  
 } 
 ); 
 // ...

Dart

  // ... 
 final 
  
 model 
  
 = 
  
 FirebaseAI 
 . 
 googleAI 
 (). 
 templateGenerativeModel 
 (); 
 final 
  
 templateID 
  
 = 
  
 remoteConfig 
 . 
 getString 
 ( 
 "template_id" 
 ); 
 final 
  
 customerName 
  
 = 
  
 'Jane' 
 ; 
 // When making the `generateContent` call, source the template ID value from Remote Config 
 var 
  
 response 
  
 = 
  
 await 
  
 model 
 . 
 generateContent 
 ( 
  
 templateID 
 , 
  
 // Provide the values for any input variables required by your template 
  
 inputs: 
  
 { 
  
 'customerName' 
 : 
  
 customerName 
 , 
  
 }, 
 ); 
 // ...

Unity

  // ... 
 var 
  
 ai 
  
 = 
  
 FirebaseAI 
 . 
 GetInstance 
 ( 
 FirebaseAI 
 . 
 Backend 
 . 
 GoogleAI 
 ()); 
 var 
  
 templateID 
  
 = 
  
 remoteConfig 
 . 
 GetValue 
 ( 
 "template_id" 
 ). 
 StringValue 
 ; 
 var 
  
 model 
  
 = 
  
 ai 
 . 
 GetTemplateGenerativeModel 
 (); 
 var 
  
 customerName 
  
 = 
  
 "Jane" 
 ; 
 try 
 { 
  
 // When making the `generateContent` call, source the template ID value from Remote Config 
  
 var 
  
 response 
  
 = 
  
 await 
  
 model 
 . 
 GenerateContentAsync 
 ( 
  
 templateID 
 , 
  
 // Provide the values for any input variables required by your template 
  
 new 
  
 Dictionary<string 
 , 
  
 object 
>  
 { 
  
 { 
  
 "customerName" 
 , 
  
 customerName 
  
 }, 
  
 } 
  
 ); 
  
 Debug 
 . 
 Log 
 ( 
 $"Response Text: {response.Text}" 
 ); 
 } 
 catch 
  
 ( 
 Exception 
  
 e 
 ) 
 { 
  
 Debug 
 . 
 LogError 
 ( 
 $"An error occurred: {e.Message}" 
 ); 
 } 
 // ...

Step 7: Run the app

Build and 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

Learn more about implementing other use cases for Remote Config and Firebase AI Logic .
For mobile apps and games:
- Test your template changes with Remote Config and A/B Testing .
- Gradually release changes using Remote Config rollouts (iOS+ and Android only).
- Use Remote Config personalization to use machine learning to determine the best settings for individual users (iOS+, Android, and Unity only).

Version templates using Remote Config Stay organized with collections Save and categorize content based on your preferences.

Step 1: Set the parameter value in the Firebase console

Step 2: Add and initialize Remote Config in your app

Swift

Kotlin

Java

Web

Dart

Unity

Step 3: Set the in-app parameter value

Swift

Kotlin

Java

Web

Dart

Unity

Step 4: Fetch and activate the value

Swift

Kotlin

Java

Web

Dart

Unity

Step 5: Add a real-time Remote Config listener

Swift

Kotlin

Java

Web

Dart

Unity

Step 6: Update the Gemini API requests to use the Remote Config value

Swift

Kotlin

Java

Web

Dart

Unity

Step 7: Run the app

Next steps

Version templates using Remote Config