Firebase Remote Config を使用して Firebase AI Logic アプリを動的に更新する

// Set default Remote Config parameter values remoteConfig.defaultConfig = {   model_name: 'gemini-2.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: 'global', }; 

remoteConfig.setDefaults(const {   "model_name": "gemini-2.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": "global" }); 

await remoteConfig.SetDefaultsAsync(   new System.Collections.Generic.Dictionary<string, object>() {     { "model_name", "gemini-2.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", "global" }   } ); 

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

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

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

// Fetch and activate Remote Config. remoteConfig.fetchAndActivate();  // Assign Remote Config values. String? _modelName = remoteConfig.getString("model_name"); String? _systemInstructions = remoteConfig.getString("system_instructions"); String? _prompt = remoteConfig.getString("prompt"); String? _vertexLocation = remoteConfig.getString("vertex_location"); 

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

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

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

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

// Add a real-time Remote Config listener remoteConfig.onConfigUpdated.listen((event) async {   await remoteConfig.activate(); }); 

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

// Initialize the Gemini Developer API backend service // The Gemini Developer API doesn't support setting the location of a model let ai = FirebaseAI.firebaseAI(backend: .googleAI())  // Create a `GenerativeModel` and add system instructions into its config // Both the model name and the system instructions will be sourced from Remote Config let modelName = remoteConfig.configValue(forKey: "model_name").stringValue let systemInstructions = remoteConfig.configValue(forKey: "system_instructions").stringValue  let model = ai.generativeModel(   modelName: modelName,   systemInstruction: ModelContent(role: "system", parts: systemInstructions) )  // Provide a prompt that contains text // The text in the prompt will be sourced from Remote Config 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) } 

// Initialize the Gemini Developer API backend service // The Gemini Developer API doesn't support setting the location of a model val ai = Firebase.ai(backend = GenerativeBackend.googleAI())  // Create a `GenerativeModel` and add system instructions into its config // Both the model name and the system instructions will be sourced from Remote Config val model = ai.generativeModel(   modelName = remoteConfig.getString("model_name"),   systemInstruction = content { text(remoteConfig.getString("system_instructions")) } )  // To generate text output, call `generateContent` with the text input // The text in the prompt will be sourced from Remote Config val response = model.generateContent(remoteConfig.getString("prompt")) print(response.text) 

// Initialize the Gemini Developer API backend service // The Gemini Developer API doesn't support setting the location of a model FirebaseAI ai = FirebaseAI.getInstance(GenerativeBackend.googleAI());  // Create a `GenerativeModel` and add system instructions into its config // Both the model name and the system instructions will be sourced from Remote Config GenerativeModel gm = ai.generativeModel(         /* modelName */ remoteConfig.getString("model_name"),         /* generationConfig (optional) */ null,         /* safetySettings (optional) */ null,         /* tools (optional) */ null,         /* toolsConfig (optional) */ null,         /* systemInstruction (optional) */ new Content.Builder().addText(                 remoteConfig.getString("system_instructions")).build(),         /* requestOptions (optional) */ new RequestOptions() ); GenerativeModelFutures model = GenerativeModelFutures.from(gm);  // Provide a prompt that contains text // The text in the prompt will be sourced from Remote Config 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); 

// Initialize FirebaseApp const firebaseApp = initializeApp(firebaseConfig);  // Initialize the Gemini Developer API backend service // The Gemini Developer API doesn't support setting the location of a model const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });  // Create a `GenerativeModel` and add system instructions into its config // Both the model name and the system instructions will be sourced from Remote Config const model = getGenerativeModel(ai, {   model: modelName,   systemInstruction: systemInstruction });  // Wrap in an async function so you can use await async function run() {   // Provide a prompt that contains text   // The text in the prompt will be sourced from Remote Config   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); } 

// Initialize the Gemini Developer API backend service // The Gemini Developer API doesn't support setting the location of a model final ai = await FirebaseAI.googleAI();  // Create a `GenerativeModel` and add system instructions into its config // Both the model name and the system instructions will be sourced from Remote Config final model =       ai.generativeModel(         model: _modelName,         systemInstruction: Content.system(_systemInstructions),       );  // Provide a prompt that contains text // The text in the prompt will be sourced from Remote Config final _userPrompt = [Content.text(_prompt)];  // To generate text output, call `generateContent` with the text input final response = await model.generateContent(_userPrompt); print(response.text); 

// Initialize the Gemini Developer API backend service // The Gemini Developer API doesn't support setting the location of a model var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());  // Create a `GenerativeModel` and add system instructions into its config // Both the model name and the system instructions will be sourced from Remote Config var modelName = remoteConfig.GetValue("model_name").StringValue; var systemInstructions = remoteConfig.GetValue("system_instructions").StringValue;  var model = ai.GetGenerativeModel(   modelName: modelName,   systemInstruction: ModelContent.Text(systemInstructions) );  // Provide a prompt that contains text // The text in the prompt will be sourced from Remote Config var userPrompt = remoteConfig.GetValue("prompt").StringValue;  // To generate text output, call `GenerateContentAsync` with the text input var response = await model.GenerateContentAsync(userPrompt); UnityEngine.Debug.Log(response.Text ?? "No text in response.");