Mengupdate Vertex AI di aplikasi Firebase secara dinamis dengan Firebase Remote Config

Saat memanggil Gemini API dari aplikasi menggunakan Vertex AI in Firebase SDK, permintaan Anda berisi sejumlah parameter yang mengontrol respons AI generatif. Hal ini biasanya mencakup nama model, konfigurasi pembuatan model (token maksimum, suhu, dll.), setelan keamanan, petunjuk sistem, dan data perintah.

Pada umumnya, Anda sebaiknya mengubahnya sesuai permintaan atau sesuai kebutuhan untuk sejumlah skenario:

  • Update model AI generatif Anda tanpa merilis aplikasi baru. Anda dapat mengupgrade ke versi model yang lebih baru dan stabil sebelum versi sebelumnya dihentikan, beralih ke model dengan biaya lebih rendah atau performa lebih tinggi berdasarkan kebutuhan dan atribut pengguna, atau men-deploy model terbaru dan terbaik secara kondisional ke segmen pengguna tertentu (seperti penguji beta).
  • Tetapkan lokasi tempat Anda mengakses model agar lebih dekat dengan pengguna.
  • Lakukan pengujian A/B pada berbagai petunjuk dan perintah sistem, lalu luncurkan nilai eksperimen yang menang secara perlahan kepada pengguna Anda.
  • Gunakan flag fitur untuk mengekspos atau menyembunyikan fitur AI generatif dengan cepat di aplikasi Anda.

Firebase Remote Config melakukan semua hal ini dan lainnya, memungkinkan Anda memperbarui parameter value sesuai kebutuhan dan secara kondisional untuk instance aplikasi yang cocok dengan karakteristik yang Anda tetapkan di konsol Firebase, tanpa merilis versi baru aplikasi Anda.

Panduan solusi ini memberikan kasus penggunaan tertentu yang direkomendasikan dan menjelaskan cara menambahkan Remote Config ke aplikasi AI generatif Anda.

Langsung ke penerapan kode

Mengapa menggunakan Firebase Remote Config dengan aplikasi Anda?

Firebase Remote Config memungkinkan Anda menyesuaikan perilaku aplikasi secara dinamis tanpa memerlukan update aplikasi. Hal ini sangat efektif untuk aplikasi yang menggunakan AI generatif, yang memerlukan iterasi dan penyesuaian yang cepat.

Kasus penggunaan penting untuk Remote Config dengan aplikasi AI generatif

Sebaiknya gunakan Remote Config dengan Vertex AI in Firebase untuk kasus penggunaan penting berikut:

  • Upgrade ke versi model terbaru tanpa update aplikasi: Gunakan parameter Remote Config untuk mengubah nama model sesuai kebutuhan, sehingga Anda dapat mengupgrade ke versi terbaru model Gemini pilihan Anda segera setelah tersedia.
  • Memperbarui petunjuk sistem dan setelan keamanan tanpa update aplikasi: Simpan petunjuk sistem dan setelan keamanan di dalam parameter Remote Config untuk memastikan bahwa Anda dapat mengubahnya sesuai permintaan jika menemukan masalah setelah deployment.
  • Mengurangi risiko dan menerapkan keamanan AI: Gunakan Peluncuran Remote Config untuk merilis perubahan AI generatif secara aman dan bertahap kepada pengguna iOS dan Android.

Kasus penggunaan lanjutan dan yang direkomendasikan untuk Remote Config dengan aplikasi AI generatif

Setelah melengkapi aplikasi dengan Remote Config dan Google Analytics, Anda dapat mempelajari kasus penggunaan lanjutan:

  • Menetapkan lokasi berdasarkan lokasi klien: Gunakan kondisi Remote Config untuk menetapkan lokasi model berdasarkan lokasi yang terdeteksi klien.
  • Bereksperimen dengan berbagai model: Uji dan beralih dengan cepat antara berbagai model AI generatif, atau bahkan deploy model yang berbeda ke segmen pengguna yang berbeda, untuk menemukan model yang paling sesuai dengan kasus penggunaan tertentu.
  • Mengoptimalkan performa model: Menyesuaikan parameter model, seperti perintah sistem, token output maksimum, suhu, dan setelan lainnya.

  • Gunakan petunjuk, perintah, dan konfigurasi model sistem yang berbeda berdasarkan atribut klien: Saat menggunakan Remote Config dengan Google Analytics, Anda dapat membuat kondisi berdasarkan atribut klien atau audiens kustom dan menetapkan parameter yang berbeda berdasarkan atribut ini.

    Misalnya, jika Anda menggunakan AI generatif untuk memberikan dukungan teknis di aplikasi, sebaiknya tetapkan petunjuk sistem khusus untuk platform aplikasi guna memastikan petunjuk yang akurat diberikan kepada pengguna platform Android, iOS, dan web.

  • Mempersonalisasi pengalaman untuk setiap pengguna: Gunakan personalisasi Remote Config untuk menentukan setelan AI generatif yang optimal untuk setiap pengguna secara otomatis.

  • Mengontrol biaya: Menyesuaikan model AI generatif mana yang dipanggil, frekuensi penggunaannya, dan mengonfigurasi nilai token output maksimum secara dinamis berdasarkan audiens pengguna untuk mengurangi biaya yang tidak perlu.

  • Optimalkan pengalaman dan hasil aplikasi: Gunakan A/B Testing dengan Remote Config dengan aplikasi iOS, Android, dan Flutter untuk menguji perubahan pada parameter AI generatif di seluruh segmen pengguna yang berbeda untuk melihat pengaruhnya terhadap metrik utama seperti retensi dan pendapatan.

Dengan melengkapi aplikasi AI generatif Anda dengan Firebase Remote Config, Anda dapat mem-build aplikasi yang didukung AI yang fleksibel, aman, dan hemat biaya sekaligus menciptakan pengalaman yang menyenangkan bagi pengguna.

Menambahkan Firebase Remote Config ke aplikasi Anda

Dalam panduan solusi ini, Anda akan menggunakan Firebase Remote Config untuk mengupdate parameter secara dinamis di aplikasi Android yang menggunakan Vertex AI in Firebase SDK. Anda akan mempelajari cara:

  • Ambil dan aktifkan parameter seperti nama model dan petunjuk sistem dari Firebase Remote Config.
  • Perbarui panggilan Gemini API untuk menggunakan parameter yang diambil secara dinamis, sehingga Anda dapat beralih antarmodel atau mengubah petunjuk sistem tanpa update aplikasi.
  • Mengontrol parameter dari jarak jauh, menyesuaikan perilaku dan kemampuan model sesuai kebutuhan.

Prasyarat

Panduan ini mengasumsikan bahwa Anda sudah terbiasa menggunakan Android Studio untuk mengembangkan aplikasi untuk platform Android. Sebelum memulai, pastikan Anda telah melakukan hal berikut:

  • Selesaikan Panduan memulai untuk Vertex AI in Firebase SDK. Pastikan Anda telah melakukan semua hal berikut:

    1. Siapkan project Firebase baru atau yang sudah ada, termasuk menggunakan paket harga Blaze dan mengaktifkan API yang diperlukan.
    2. Menghubungkan aplikasi ke Firebase, termasuk mendaftarkan aplikasi dan menambahkan konfigurasi Firebase ke aplikasi.
    3. Tambahkan SDK dan lakukan inisialisasi layanan Vertex AI dan model generatif di aplikasi Anda.

  • Aktifkan Google Analytics dalam project Anda dan tambahkan SDK-nya ke aplikasi Anda (diperlukan untuk penargetan bersyarat, seperti menetapkan lokasi layanan dan model berdasarkan lokasi perangkat klien).

Langkah 1: Tetapkan parameter value di konsol Firebase

Buat template Remote Config klien dan konfigurasikan parameter serta nilai yang akan diambil dan digunakan di aplikasi.

  1. Buka project Firebase Anda di konsol Firebase, lalu dari menu navigasi, luaskan Run dan pilih Remote Config.
  2. Pastikan Client dipilih dari pemilih Client/Server di bagian atas halaman Remote Config.
    • Jika ini pertama kalinya Anda menggunakan template klien Remote Config, klik Create Configuration. Panel Create your first parameter akan muncul.
    • Jika ini bukan pertama kalinya Anda menggunakan template Remote Config, klik Add parameter.

  3. Tentukan parameter Remote Config berikut:

    Nama parameter Deskripsi Jenis Nilai default
    model_name Nama model. Untuk daftar terbaru nama model yang akan digunakan dalam kode Anda, lihat Nama model yang tersedia. String gemini-1.5-flash
    system_instructions Petunjuk sistem seperti "preamble" yang Anda tambahkan sebelum model diekspos ke petunjuk lebih lanjut dari pengguna akhir untuk memengaruhi perilaku model, berdasarkan kebutuhan dan kasus penggunaan tertentu. String You are a helpful assistant who knows everything there is to know about Firebase!
    prompt Perintah default yang akan digunakan dengan fitur AI generatif Anda. String I am a developer who wants to know more about Firebase!
    vertex_location Secara opsional, kontrol lokasi untuk menjalankan layanan Vertex AI dan mengakses model. Anda dapat menetapkan kondisi untuk mengonfigurasi opsi ini berdasarkan lokasi klien yang terdeteksi oleh Google Analytics. String us-central1

  4. Setelah menambahkan parameter, klik Publish changes. Jika ini bukan template Remote Config baru, tinjau perubahan, lalu klik Publish changes lagi.

Langkah 2: Tambahkan dan lakukan inisialisasi Remote Config SDK di aplikasi Anda

Tambahkan dependensi Remote Config dan siapkan Remote Config dalam aplikasi Anda.

  1. Tambahkan dependensi Remote Config ke file Gradle modul (level aplikasi) (biasanya app/build.gradle.kts atau app/build.gradle):

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

  2. Tambahkan Remote Config ke logika aplikasi utama Anda. Di sini, Anda akan melakukan inisialisasi Remote Config dan menambahkan interval pengambilan minimum:

    Kotlin+KTX 

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

    Java 

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

Dalam contoh ini, interval pengambilan default adalah 3.600 detik, tetapi sebaiknya Anda menetapkan interval pengambilan minimum yang relatif rendah di dalam kode selama pengembangan.

Langkah 3: Menetapkan parameter value dalam aplikasi

Anda harus menetapkan parameter value default dalam aplikasi di objek Remote Config. Hal ini memastikan bahwa aplikasi Anda berperilaku seperti yang diharapkan meskipun tidak dapat mengambil nilai dari layanan Remote Config.

  1. Dari Firebase console, buka Remote Config.
  2. Di tab Parameters, buka Menu, lalu pilih Download default values.
  3. Jika diminta, aktifkan .xml for Android, lalu klik Download file.
  4. Simpan file di direktori resource XML aplikasi Anda.

  5. Perbarui file aktivitas utama untuk menambahkan default setelah configSettings yang Anda tambahkan sebelumnya:

    Kotlin+KTX 

    // Set default values.
remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

    Java 

    // Set default values.
mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Langkah 4: Mengambil dan mengaktifkan nilai

Setelah menetapkan default, tambahkan kode berikut untuk mengambil dan mengaktifkan nilai:

Kotlin+KTX 

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

Langkah 5: Tambahkan pemroses Remote Config real-time

Tambahkan pemroses Remote Config real-time ke aplikasi Anda untuk memastikan bahwa perubahan yang Anda buat pada template Remote Config disebarkan ke klien segera setelah diperbarui.

Kode berikut memperbarui objek Remote Config setiap kali nilai parameter berubah. Secara opsional, Anda juga dapat mengonfigurasi tindakan di dalam aktivasi addOnCompleteListener:

Kotlin+KTX 

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

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

Langkah 6: Tetapkan nilai Remote Config ke variabel Vertex AI

Setelah Remote Config dikonfigurasi sepenuhnya, perbarui kode Anda untuk mengganti nilai hardcode dengan nilai yang bersumber dari Remote Config.

Ganti nilai hardcode untuk lokasi, nama model, petunjuk sistem, dan perintah pengguna dengan nilai yang bersumber dari Remote Config.

Kotlin+KTX 

// Initialize FirebaseVertexAI instance
// Optionally specify a location in which to run the service and access the model
val vertexAI = Firebase.vertexAI(location = remoteConfig.getString("vertex_location"))

// Initialize the Vertex AI service and the generative model
// Specify a model that supports system instructions, like a Gemini 1.5 model
val generativeModel = Firebase.vertexAI.generativeModel(
  modelName = remoteConfig.getString("model_name"),
  systemInstruction = content { text(remoteConfig.getString("system_instructions")) }
)

// To generate text output, call generateContent with the text input
val response = generativeModel.generateContent(remoteConfig.getString("prompt"))
print(response.text)

Java 

// Initialize FirebaseVertexAI instance
// Optionally specify a location in which to run the service and access the model
FirebaseVertexAI vertexAI = FirebaseVertexAI.getInstance(remoteConfig.getString("vertex_location"));

// Initialize the Vertex AI service and the generative model
// Specify a model that supports system instructions, like a Gemini 1.5 model
GenerativeModel gm = FirebaseVertexAI.getInstance().generativeModel(
  /* modelName */ remoteConfig.getString("model_name"),
  /* generationConfig (optional) */ null,
  /* safetySettings (optional) */ null,
  /* requestOptions (optional) */ new RequestOptions(),
  /* tools (optional) */ null,
  /* toolsConfig (optional) */ null,
  /* systemInstruction (optional) */ new Content.Builder().addText(remoteConfig.getString("system_instructions")).build()
);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// Provide a prompt that contains text
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);

Langkah 7: Jalankan aplikasi

Build dan jalankan aplikasi, lalu pastikan aplikasi berfungsi. Lakukan perubahan pada konfigurasi Anda dari halaman Remote Config di Firebase console, publikasikan perubahan, dan verifikasi hasilnya.

Langkah berikutnya