Dynamiczne aktualizowanie aplikacji Firebase AI Logic za pomocą Zdalnej konfiguracji Firebase

Gdy wywołujesz Gemini API z aplikacji za pomocą pakietu SDK Firebase AI Logic, Twoje żądanie zawiera szereg parametrów, które kontrolują odpowiedzi generatywnej AI. Zwykle obejmują one nazwę modelu, konfigurację generacji modelu (maksymalna liczba tokenów, temperatura itp.), ustawienia bezpieczeństwa, instrukcje systemowe i dane promptu.

W większości przypadków warto zmieniać te ustawienia na żądanie lub w razie potrzeby w różnych sytuacjach:

  • Aktualizuj model generatywnej AI bez publikowania nowej aplikacji. Możesz przejść na nowsze, stabilne wersje modelu, zanim starsze wersje zostaną wycofane, przejść na tańsze lub wydajniejsze modele w zależności od potrzeb i atrybutów użytkowników lub warunkowo wdrażać najnowsze i najlepsze modele w określonych segmentach użytkowników (np. w przypadku testerów beta).
  • Ustaw lokalizację, w której uzyskujesz dostęp do modelu, aby była bliżej Twoich użytkowników.
  • Przeprowadzaj testy A/B różnych instrukcji systemowych i promptów, a następnie stopniowo wdrażaj u użytkowników wartości eksperymentu, który przyniósł najlepsze wyniki.
  • Używaj flag funkcji, aby szybko udostępniać lub ukrywać funkcje generatywnej AI w aplikacji.

Firebase Remote Config robi to wszystko i jeszcze więcej. Umożliwia aktualizowanie wartości parametrów w razie potrzeby i warunkowo w przypadku instancji aplikacji, które pasują do cech ustawionych w konsoli Firebase, bez publikowania nowej wersji aplikacji.

Ten przewodnik po rozwiązaniach zawiera konkretne zalecane przypadki użycia i opisuje, jak dodać Remote Config do aplikacji z generatywną AI.

Przejdź do implementacji kodu

Dlaczego warto korzystać z Firebase Remote Config w aplikacji?

Firebase Remote Config umożliwia dynamiczne dostosowywanie działania aplikacji bez konieczności jej aktualizowania. Jest to szczególnie przydatne w przypadku aplikacji korzystających z generatywnej AI, w których szybkie iteracje i dostrajanie są kluczowe.

Najważniejsze zastosowania Remote Config w aplikacjach z generatywną AI

Zalecamy używanie atrybutu Remote Config z atrybutem Firebase AI Logic w tych podstawowych przypadkach użycia:

  • Przejdź na najnowszą wersję modelu bez aktualizowania aplikacji: użyj parametrów Remote Config, aby w razie potrzeby zmienić nazwę modelu. Dzięki temu możesz przejść na najnowszą wersję preferowanego modelu Gemini, gdy tylko będzie dostępna.

  • Aktualizowanie instrukcji systemowych i ustawień bezpieczeństwa bez aktualizacji aplikacji: przechowuj instrukcje systemowe i ustawienia bezpieczeństwa w Remote Config parametrach, aby w razie wykrycia problemów po wdrożeniu móc je zmieniać na żądanie.

  • Zmniejszanie ryzyka i egzekwowanie bezpieczeństwa AI: korzystaj z Remote Configwdrażania etapowego, aby bezpiecznie i stopniowo udostępniać zmiany w generatywnej AI użytkownikom iOS i Androida.

Zaawansowane i zalecane przypadki użycia Remote Config w aplikacjach z generatywną AI

Po zintegrowaniu aplikacji z Remote Config i Google Analytics możesz poznać zaawansowane przypadki użycia:

  • Ustaw lokalizację na podstawie lokalizacji klienta: użyj Remote Configwarunków, aby ustawić lokalizację, w której uzyskujesz dostęp do modelu, na podstawie wykrytej lokalizacji klienta.

  • Eksperymentowanie z różnymi modelami: szybkie testowanie różnych modeli generatywnej AI i przełączanie się między nimi, a nawet uzyskiwanie dostępu do różnych modeli dla różnych segmentów użytkowników, aby znaleźć najlepsze rozwiązanie dla konkretnego przypadku użycia.

  • Optymalizacja wydajności modelu: dostosuj parametry modelu, takie jak prompt systemowy, maksymalna liczba tokenów wyjściowych, temperatura i inne ustawienia.

  • Używaj różnych instrukcji systemowych, promptów i konfiguracji modelu w zależności od atrybutów klienta: gdy używasz Remote Config z Google Analytics, możesz tworzyć warunki na podstawie atrybutów klienta lub niestandardowych grup odbiorców i ustawiać różne parametry na podstawie tych atrybutów.

    Jeśli na przykład używasz generatywnej AI do zapewniania pomocy technicznej w aplikacji, możesz ustawić instrukcje systemowe dostosowane do platformy aplikacji, aby użytkownicy Androida, iOS i platformy internetowej otrzymywali dokładne instrukcje.

  • Personalizowanie wrażeń każdego użytkownika: używaj Remote Config personalizacji w aplikacjach i grach mobilnych, aby automatycznie określać optymalne ustawienia generatywnej AI dla każdego użytkownika.

  • Kontrolowanie kosztów: zdalnie dostosowuj, które modele generatywnej AI są wywoływane, jak często są używane, i dynamicznie konfiguruj maksymalne wartości tokenów wyjściowych na podstawie grupy odbiorców, aby ograniczyć niepotrzebne koszty.

  • Optymalizuj wrażenia użytkowników i wyniki aplikacji: używaj A/B Testing z Remote Config w aplikacjach i grach mobilnych, aby testować zmiany parametrów generatywnej AI w różnych segmentach użytkowników i sprawdzać, jak wpływają one na kluczowe dane, takie jak utrzymanie użytkowników i przychody.

Dzięki zintegrowaniu aplikacji generatywnej AI z Firebase Remote Config możesz tworzyć elastyczne, bezpieczne i ekonomiczne aplikacje oparte na AI, a jednocześnie zapewniać użytkownikom doskonałe wrażenia.

Dodawanie Firebase Remote Config do aplikacji

W tym przewodniku po rozwiązaniach użyjesz Firebase Remote Config, aby dynamicznie aktualizować parametry w aplikacji na Androida, która korzysta z pakietu SDK Firebase AI Logic. Zapoznasz się z tymi zagadnieniami:

  • Pobieraj i aktywuj parametry, takie jak nazwy modeli i instrukcje systemowe, z Firebase Remote Config.
  • Zaktualizuj wywołania Gemini API, aby używać parametrów pobieranych dynamicznie. Dzięki temu możesz przełączać się między różnymi modelami lub modyfikować instrukcje systemowe bez aktualizowania aplikacji.
  • zdalnie sterować parametrami, dostosowując w razie potrzeby zachowanie i możliwości modelu;

Wymagania wstępne

W tym przewodniku przyjęto założenie, że znasz podstawy tworzenia aplikacji na swoją platformę.

Zanim zaczniesz, wykonaj te czynności:

  • Zapoznaj się z Firebase AI Logicprzewodnikiem dla początkujących, w którym znajdziesz informacje o konfigurowaniu projektu Firebase, łączeniu aplikacji z Firebase, dodawaniu pakietu SDK, inicjowaniu usługi backendu dla wybranego dostawcy „Gemini API” i tworzeniu instancji modelu.

  • Włącz Google Analytics w projekcie Firebase i dodaj jego pakiet SDK do aplikacji (wymagane w przypadku kierowania warunkowego, np. ustawiania lokalizacji, w której uzyskujesz dostęp do modelu, na podstawie lokalizacji urządzenia klienta).

Krok 1. Ustaw wartości parametrów w konsoli Firebase.

Utwórz Remote Configszablon klienta i skonfiguruj parametry oraz wartości, które mają być pobierane i używane w aplikacji.

  1. Otwórz projekt Firebase w Firebasekonsoli. Następnie w menu nawigacyjnym rozwiń Uruchom i wybierz Remote Config.
  2. Upewnij się, że w selektorze Klient/Serwer u góry strony wybrano Klient.
  3. Aby rozpocząć tworzenie szablonu klienta, kliknij Utwórz konfigurację (lub Dodaj parametr, jeśli szablonów klientów używasz już wcześniej).

  4. Określ parametry, którymi chcesz sterować za pomocą Remote Config. Przykład:

    Nazwa parametru Opis Typ Wartość domyślna
    model_name Nazwa modelu. Zobacz dostępne nazwy modeli. Ciąg znaków gemini-2.5-flash
    system_instructions Instrukcje systemowe to rodzaj „wstępu”, który dodajesz, zanim model otrzyma dalsze instrukcje od użytkownika, aby wpłynąć na jego działanie. Ciąg znaków You are a helpful assistant who knows everything there is to know about Firebase!
    prompt Domyślny prompt do użycia z funkcją generatywnej AI. Ciąg znaków I am a developer who wants to know more about Firebase!
    vertex_location Ma zastosowanie tylko w przypadku korzystania z Vertex AI Gemini API.
     Kontroluj lokalizację, aby uzyskać dostęp do modelu. Możesz ustawić warunki, aby skonfigurować tę opcję na podstawie lokalizacji klienta wykrytej przez Google Analytics.    		 Ciąg znaków global

  5. Gdy skończysz dodawać parametry, kliknij Opublikuj zmiany. Jeśli to nie jest nowy szablon Remote Config, sprawdź zmiany i ponownie kliknij Opublikuj zmiany.

Krok 2. Dodaj i zainicjuj Remote Config w aplikacji

Dodaj bibliotekę Remote Config i skonfiguruj Remote Config w aplikacji.

Swift

W ramach Firebase AI Logickonfiguracji pakiet SDK Firebase został już dodany do aplikacji, ale musisz też dodać Remote Config.

  1. W Xcode otwórz projekt i kliknij File > Add Package Dependencies (Plik > Dodaj zależności pakietu).

  2. Wybierz firebase-ios-sdk, a następnie kliknij Add package (Dodaj pakiet).

  3. W nawigatorze projektu wybierz aplikację > Cele > aplikację.

  4. Na karcie Ogólne przewiń do sekcji Frameworki, biblioteki i treści osadzone.

  5. Kliknij + i wybierz FirebaseRemoteConfig, a potem kliknij Dodaj.

  6. Dodaj do kodu import FirebaseRemoteConfig:

    import FirebaseRemoteConfig

  7. W odpowiedniej klasie aplikacji zainicjuj Firebase i dodajRemote Config do głównej logiki aplikacji.

    W tym miejscu dodaj Remote Config i Remote Config odbiornik w czasie rzeczywistym jako importy, aby aplikacja mogła pobierać nowe wartości w czasie rzeczywistym, oraz dodaj minimalny interwał pobierania:

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

    W aplikacji z krótkiego wprowadzenia będzie to w VertexAISampleApp w klasie AppDelegate.

Kotlin

  1. Dodaj zależność Remote Config do pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle.kts lub app/build.gradle):

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

  2. Dodaj Remote Config do głównej logiki aplikacji. Tutaj zainicjujesz Remote Config i dodasz minimalny interwał pobierania:

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

Java

  1. Dodaj zależność Remote Config do pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle.kts lub app/build.gradle):

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

  2. Dodaj Remote Config do głównej logiki aplikacji. Tutaj zainicjujesz Remote Config i dodasz minimalny interwał pobierania:

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

Web

  1. Otwórz kod w edytorze tekstu i zaimportuj Remote Config:

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

  2. W funkcji głównej i po zainicjowaniu aplikacji Firebase dla pakietu SDK Firebase AI Logic zainicjuj Remote Config:

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

  3. Ustaw minimalny odstęp czasu pobierania:

    remoteConfig.settings.minimumFetchIntervalMillis = 3600000;

Dart

  1. W katalogu projektu Flutter zainstaluj i dodaj Remote Configza pomocą tego polecenia:

    flutter pub add firebase_remote_config

  2. Otwórz plik ./lib/main.dart i dodaj instrukcję importu po innych instrukcjach importu dodanych w celu obsługi 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';

  3. Dodaj do aplikacji zmienne _modelName, _systemInstructions i _prompt, abyśmy mogli ich później użyć:

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

  4. Pobierz instancję obiektu Remote Config i ustaw minimalny interwał pobierania, aby umożliwić częste odświeżanie. Pamiętaj, aby dodać ten kod po zainicjowaniu Firebase.

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

Unity

  1. Dodaj Remote Config do projektu Unity, postępując zgodnie z tymi instrukcjami.

  2. Pobierz instancję obiektu Remote Config i ustaw minimalny interwał pobierania, aby umożliwić częste odświeżanie. Pamiętaj, aby dodać ten kod po zainicjowaniu Firebase.

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

Krok 3. Ustaw wartości parametrów w aplikacji

Wartości domyślne parametrów w aplikacji należy ustawić w obiekcie Remote Config. Dzięki temu aplikacja będzie działać zgodnie z oczekiwaniami nawet wtedy, gdy nie będzie mogła pobrać wartości z usługi Remote Config.

Swift

  1. W konsoli Firebase otwórz Remote Config.

  2. Na karcie Parametry otwórz Menu i kliknij Pobierz wartości domyślne.

  3. Gdy pojawi się odpowiedni komunikat, włącz .plist dla iOS, a następnie kliknij Pobierz plik.

  4. Zapisz plik w katalogu aplikacji.

    Jeśli używasz przykładowej aplikacji, zapisz ją w folderze FirebaseVertexAI/Sample/VertexAISample.

  5. W Xcode kliknij prawym przyciskiem myszy aplikację i wybierz Add Files (Dodaj pliki).

    Jeśli używasz przykładu, kliknij prawym przyciskiem myszy VertexAISample i wybierz Dodaj pliki do „VertexAISample”.

  6. Wybierz remote_config_defaults.plist, a potem kliknij Dodaj.

  7. Zaktualizuj kod aplikacji, aby odwoływał się do pliku domyślnego:

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

Kotlin

  1. Na konsoli Firebase otwórz Remote Config.

  2. Na karcie Parametry otwórz Menu i kliknij Pobierz wartości domyślne.

  3. Gdy pojawi się odpowiedni komunikat, włącz .xml na Androida, a potem kliknij Pobierz plik.

  4. Zapisz plik w katalogu zasobów XML aplikacji.

  5. Zaktualizuj główny plik aktywności, aby dodać wartości domyślne po dodanym wcześniej tagu configSettings:

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

Java

  1. W konsoli Firebase otwórz Remote Config.

  2. Na karcie Parametry otwórz Menu i kliknij Pobierz wartości domyślne.

  3. Gdy pojawi się odpowiedni komunikat, włącz .xml na Androida, a potem kliknij Pobierz plik.

  4. Zapisz plik w katalogu zasobów XML aplikacji.

  5. Zaktualizuj główny plik aktywności, aby dodać wartości domyślne po dodanym wcześniej tagu configSettings:

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

Web

Wartości domyślne możesz ustawić bezpośrednio w kodzie:

// 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',
};

Dart

Wartości domyślne możesz ustawić bezpośrednio w kodzie:

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

Unity

Wartości domyślne możesz ustawić bezpośrednio w kodzie:

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

Krok 4. Pobierz i aktywuj wartości

Po ustawieniu wartości domyślnych dodaj poniższy kod, aby pobrać i aktywować wartości.

Swift 

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

Powinno to aktualizować obiekt Remote Config za każdym razem, gdy zostanie opublikowany nowy szablon Remote Config.

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

  1. Dodaj do importów getValue i fetchAndActivate:

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

  2. Po dodaniu kodu do skonfigurowania domyślnych wartości Remote Config pobierz i aktywuj konfigurację, a następnie przypisz wartości do stałych modelName, systemInstructions, prompt i vertexLocation.

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

Dart 

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

Unity 

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

Krok 5. Dodaj słuchacza Remote Config w czasie rzeczywistym

Dodaj do aplikacji odbiornik Remote Config czasu rzeczywistego, aby mieć pewność, że zmiany wprowadzone w Remote Config szablonie są przekazywane do klienta natychmiast po aktualizacji.

Poniższy kod aktualizuje obiekt Remote Config za każdym razem, gdy zmienia się wartość parametru.

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

Opcjonalnie możesz też skonfigurować działanie w ramach aktywacji:addOnCompleteListener

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

Opcjonalnie możesz też skonfigurować działanie w ramach aktywacji:addOnCompleteListener

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

Odbiorniki Remote Config w czasie rzeczywistym nie są obsługiwane w przypadku aplikacji internetowych.

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

Krok 6. Zaktualizuj żądania Gemini API, aby używać wartości Remote Config.

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dostawcy.

Teraz, gdy usługa Remote Config jest w pełni skonfigurowana, zaktualizuj kod, aby zastąpić zakodowane na stałe wartości wartościami pochodzącymi z usługi Remote Config.

Swift 

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

Kotlin 

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

Java 

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

Web 

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

Dart 

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

Unity 

// 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.");

Krok 7. Uruchom aplikację.

Skompiluj i uruchom aplikację oraz sprawdź, czy działa. Wprowadź zmiany w konfiguracji na stronie Remote Config w konsoli Firebase, opublikuj je i sprawdź wynik.

Dalsze kroki