עדכון דינמי של אפליקציית הלוגיקה של Firebase AI באמצעות הגדרת תצורה מרחוק ב-Firebase

כשקוראים ל-Gemini API מהאפליקציה באמצעות SDK של Firebase AI Logic, הבקשה מכילה מספר פרמטרים ששולטים בתשובות של AI גנרטיבי. הם כוללים בדרך כלל את שם המודל, את הגדרות הדור של המודל (מספר מקסימלי של טוקנים, טמפרטורה וכו'), הגדרות בטיחות, הוראות מערכת ונתוני הנחיה.

ברוב המקרים, כדאי לשנות את ההגדרות האלה לפי דרישה או לפי הצורך במספר תרחישים:

  • עדכון מודל AI גנרטיבי בלי לפרסם אפליקציה חדשה. אתם יכולים לשדרג לגרסאות חדשות ויציבות יותר של המודל לפני שגרסאות קודמות יוצאות משימוש, לעבור למודלים זולים יותר או למודלים עם ביצועים טובים יותר בהתאם לצרכים ולמאפיינים של המשתמשים, או לפרוס באופן מותנה את המודלים הכי חדשים והכי טובים לפלחים ספציפיים של משתמשים (כמו בודקי בטא).
  • כדאי להגדיר את המיקום שבו ניגשים למודל כך שיהיה קרוב יותר למשתמשים.
  • עורכים בדיקות A/B להנחיות ולהוראות מערכת שונות, ואז משיקים בהדרגה למשתמשים את הערכים של הניסוי המצליח.
  • אתם יכולים להשתמש בדגלי תכונות כדי להציג או להסתיר במהירות תכונות מבוססות-AI גנרטיבי באפליקציה שלכם.

Firebase Remote Config עושה את כל זה ועוד, ומאפשרת לכם לעדכן ערכי פרמטרים לפי הצורך ובתנאי עבור מופעי אפליקציה שתואמים למאפיינים שהגדרתם במסוף Firebase, בלי שתצטרכו להשיק גרסה חדשה של האפליקציה.

במדריך הזה לפתרונות מפורטים תרחישי שימוש מומלצים ספציפיים, ומוסבר בו איך להוסיף את Remote Config לאפליקציית ה-AI הגנרטיבי.

מעבר להטמעת הקוד

למה כדאי להשתמש ב-Firebase Remote Config באפליקציה?

‫Firebase Remote Config מאפשר לכם לשנות את ההתנהגות של האפליקציה באופן דינמי, בלי שתצטרכו לעדכן אותה. האפשרות הזו שימושית במיוחד לאפליקציות שמבוססות על AI גנרטיבי, שבהן חשוב לבצע איטרציות מהירות וכוונון עדין.

תרחישי שימוש חיוניים ב-Remote Config עם אפליקציות AI גנרטיבי

מומלץ להשתמש ב-Remote Config עם Firebase AI Logic בתרחישי השימוש החיוניים הבאים:

  • שדרוג לגרסה העדכנית ביותר של המודל בלי לעדכן את האפליקציה: משתמשים בפרמטרים של Remote Config כדי לשנות את שם המודל לפי הצורך, כדי שתוכלו לשדרג לגרסה העדכנית ביותר של מודל Gemini המועדף עליכם ברגע שהיא תהיה זמינה.

  • עדכון הוראות המערכת והגדרות הבטיחות ללא עדכון האפליקציה: אחסון הוראות המערכת והגדרות הבטיחות בתוך Remote Config פרמטרים כדי להבטיח שאפשר יהיה לשנות אותם לפי דרישה אם יתגלו בעיות אחרי הפריסה.

  • צמצום הסיכון ואכיפת בטיחות ה-AI: משתמשים בRemote Config השקות כדי להשיק שינויים ב-AI גנרטיבי למשתמשי iOS ו-Android בצורה בטוחה והדרגתית.

תרחישים מתקדמים ומומלצים לשימוש ב-Remote Config עם אפליקציות AI גנרטיבי

אחרי שמטמיעים את Remote Config ו-Google Analytics באפליקציה, אפשר לבדוק תרחישי שימוש מתקדמים:

  • הגדרת מיקום על סמך מיקום הלקוח: משתמשים בתנאי Remote Config כדי להגדיר את המיקום שבו ניגשים למודל על סמך המיקום שזוהה של הלקוח.

  • התנסות במודלים שונים: אפשר לבדוק במהירות מודלים שונים של AI גנרטיבי ולעבור ביניהם, או אפילו לגשת למודלים שונים עבור פלחי משתמשים שונים, כדי למצוא את המודל שהכי מתאים לתרחיש השימוש הספציפי שלכם.

  • אופטימיזציה של ביצועי המודל: שינוי פרמטרים של המודל, כמו הנחיית המערכת, מספר הטוקנים המקסימלי של הפלט, הטמפרטורה והגדרות אחרות.

  • שימוש בהנחיות שונות, בהוראות מערכת שונות ובהגדרות מודל שונות על סמך מאפייני לקוח: כשמשתמשים ב-Remote Config עם Google Analytics, אפשר ליצור תנאים על סמך מאפייני לקוח או קהלים בהתאמה אישית ולהגדיר פרמטרים שונים על סמך המאפיינים האלה.

    לדוגמה, אם אתם משתמשים ב-AI גנרטיבי כדי לספק תמיכה טכנית באפליקציה, כדאי להגדיר הוראות מערכת שספציפיות לפלטפורמת האפליקציה כדי לוודא שההוראות שמוצגות למשתמשי Android,‏ iOS ופלטפורמת האינטרנט מדויקות.

  • התאמה אישית של חוויות לכל משתמש: אפשר להשתמש בRemote Config התאמה אישית באפליקציות ובמשחקים לנייד כדי לקבוע באופן אוטומטי את ההגדרות האופטימליות של AI גנרטיבי לכל משתמש.

  • שליטה בעלויות: אפשר לשנות מרחוק את המודלים של ה-AI הגנרטיבי שמופעלים, את התדירות שבה הם מופעלים ולהגדיר באופן דינמי את הערכים המקסימליים של טוקנים של פלט על סמך קהל המשתמשים, כדי לצמצם עלויות מיותרות.

  • אופטימיזציה של חוויית המשתמש באפליקציה והתוצאות: אפשר להשתמש ב-A/B Testing עם Remote Config באפליקציות ובמשחקים לנייד כדי לבדוק שינויים בפרמטרים של AI גנרטיבי בפלחי משתמשים שונים, ולראות איך הם משפיעים על מדדים מרכזיים כמו שימור משתמשים והכנסות.

הוספת Firebase Remote Config לאפליקציה מבוססת-AI גנרטיבי מאפשרת לכם ליצור אפליקציות גמישות, בטוחות וחסכוניות מבוססות-AI, וגם לספק למשתמשים חוויה נעימה.

הוספת Firebase Remote Config לאפליקציה

במדריך הפתרון הזה, תשתמשו ב-Firebase Remote Config כדי לעדכן באופן דינמי פרמטרים באפליקציית Android שמשתמשת ב-Firebase AI Logic SDK. תלמדו איך:

  • מאחזרים ומפעילים פרמטרים כמו שמות של מודלים והוראות למערכת מ-Firebase Remote Config.
  • מעדכנים את הקריאות ל-Gemini API כדי להשתמש בפרמטרים שאוחזרו באופן דינמי, וכך אפשר לעבור בין מודלים שונים או לשנות את הוראות המערכת בלי לעדכן את האפליקציה.
  • שליטה בפרמטרים מרחוק, שינוי ההתנהגות והיכולות של המודל לפי הצורך.

דרישות מוקדמות

במדריך הזה אנחנו יוצאים מנקודת הנחה שאתם מכירים את תהליך פיתוח האפליקציות לפלטפורמה שלכם.

לפני שמתחילים, חשוב לוודא שביצעתם את הפעולות הבאות:

  • כדאי לעיין בFirebase AI Logicמדריך לתחילת העבודה, שבו מוסבר איך להגדיר את פרויקט Firebase, לחבר את האפליקציה ל-Firebase, להוסיף את ה-SDK, לאתחל את שירות ה-Backend עבור ספק Gemini API שבחרתם וליצור מופע של מודל.

  • מפעילים את Google Analytics בפרויקט Firebase ומוסיפים את ה-SDK שלו לאפליקציה (נדרש לטירגוט מותנה, כמו הגדרת המיקום שבו ניגשים למודל על סמך המיקום של מכשיר הלקוח).

שלב 1: הגדרת ערכי הפרמטר במסוף Firebase

יוצרים Remote Configתבנית לקוח ומגדירים פרמטרים וערכים לאחזור ולשימוש באפליקציה.

  1. פותחים את פרויקט Firebase במסוף Firebase. בתפריט הניווט, מרחיבים את Run (הפעלה) ובוחרים באפשרות Remote Config.
  2. מוודאים שהאפשרות Client נבחרה בתפריט Client/Server בחלק העליון של הדף.
  3. כדי להתחיל תבנית לקוח, לוחצים על יצירת הגדרה (או על הוספת פרמטר אם השתמשתם בעבר בתבניות לקוח).

  4. מגדירים את הפרמטרים שרוצים לשלוט בהם באמצעות Remote Config. לדוגמה:

    שם הפרמטר תיאור סוג ערך ברירת המחדל
    model_name שם הדגם. שמות המודלים הזמינים מחרוזת gemini-2.5-flash
    system_instructions הוראות למערכת הן כמו "מבוא" שמוסיפים לפני שהמודל נחשף להוראות נוספות ממשתמש הקצה, כדי להשפיע על התנהגות המודל. מחרוזת You are a helpful assistant who knows everything there is to know about Firebase!
    prompt הנחיית ברירת המחדל לשימוש בתכונת ה-AI הגנרטיבי. מחרוזת I am a developer who wants to know more about Firebase!
    vertex_location רלוונטי רק אם משתמשים ב-Vertex AI Gemini API.
    שליטה במיקום כדי לגשת למודל. אתם יכולים להגדיר תנאים כדי לקבוע את האפשרות הזו על סמך המיקום של הלקוח שזוהה על ידי Google Analytics.    		 מחרוזת global

  5. כשמסיימים להוסיף פרמטרים, לוחצים על פרסום השינויים. אם זו לא תבנית חדשה של Remote Config, בודקים את השינויים ולוחצים שוב על פרסום השינויים.

שלב 2: מוסיפים את Remote Config לאפליקציה ומפעילים אותה

מוסיפים את ספריית Remote Config ומגדירים את Remote Config באפליקציה.

Swift

במסגרת Firebase AI Logicההגדרה, כבר הוספתם את Firebase SDK לאפליקציה, אבל תצטרכו גם להוסיף את Remote Config.

  1. ב-Xcode, כשהפרויקט פתוח, עוברים אל File > Add Package Dependencies (קובץ > הוספת תלות בחבילה).

  2. בוחרים באפשרות firebase-ios-sdk ואז לוחצים על Add package (הוספת חבילה).

  3. בסרגל הניווט של הפרויקט, בוחרים את האפליקציה > Targets (יעדים) > האפליקציה.

  4. בכרטיסייה כללי, גוללים אל מסגרות, ספריות ותוכן מוטמע.

  5. לוחצים על +, בוחרים באפשרות FirebaseRemoteConfig ולוחצים על Add (הוספה).

  6. מוסיפים את הייבוא של FirebaseRemoteConfig לקוד:

    import FirebaseRemoteConfig

  7. בתוך המחלקה המתאימה לאפליקציה, מאתחלים את Firebase ומוסיפים את הקוד Remote Config ללוגיקה הראשית של האפליקציה.

    כאן צריך לכלול את Remote Config ואת Remote Config מאזין בזמן אמת כייבוא, כדי שהאפליקציה תוכל לאחזר ערכים חדשים בזמן אמת, ולהוסיף מרווח מינימלי בין אחזורי נתונים:

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

    באפליקציה למתחילים, הקוד הזה נמצא בתוך VertexAISampleApp, בכיתה AppDelegate.

Kotlin

  1. מוסיפים את התלות Remote Config לקובץ Gradle של המודול (ברמת האפליקציה) (בדרך כלל app/build.gradle.kts או 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. מוסיפים את Remote Config ללוגיקה הראשית של האפליקציה. כאן מאתחלים את Remote Config ומוסיפים מרווח מינימלי בין אחזורים:

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

Java

  1. מוסיפים את התלות Remote Config לקובץ Gradle של המודול (ברמת האפליקציה) (בדרך כלל app/build.gradle.kts או 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. מוסיפים את Remote Config ללוגיקה הראשית של האפליקציה. כאן מאתחלים את Remote Config ומוסיפים מרווח מינימלי בין אחזורים:

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

Web

  1. פותחים את הקוד בכלי לעריכת טקסט ומייבאים את Remote Config:

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

  2. בתוך הפונקציה הראשית ואחרי שאפליקציית Firebase מאותחלת עבור Firebase AI Logic SDK, מאתחלים את Remote Config:

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

  3. הגדרת מרווח מינימלי לאחזור:

    ‫
    remoteConfig.settings.minimumFetchIntervalMillis = 3600000;

Dart

  1. מתיקיית הפרויקט של Flutter, מתקינים ומוסיפים את Remote Config באמצעות הפקודה הבאה:

    flutter pub add firebase_remote_config

  2. פותחים את ./lib/main.dart ומוסיפים את הייבוא אחרי הייבואות האחרים שהוספתם כדי לתמוך ב-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. מוסיפים לאפליקציה את המשתנים _modelName, _systemInstructions ו-_prompt כדי שנוכל להשתמש בהם בהמשך:

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

  4. משיגים את מופע האובייקט Remote Config ומגדירים מרווח זמן מינימלי לאחזור כדי לאפשר למערכת לבצע רענון בתדירות גבוהה. חשוב להוסיף את השורה הזו אחרי האתחול של Firebase.

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

Unity

  1. מוסיפים את Remote Config לפרויקט Unity לפי ההוראות האלה.

  2. משיגים את מופע האובייקט Remote Config ומגדירים מרווח זמן מינימלי לאחזור כדי לאפשר למערכת לבצע רענון בתדירות גבוהה. חשוב להוסיף את השורה הזו אחרי האתחול של Firebase.

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

שלב 3: הגדרת ערכי פרמטרים באפליקציה

צריך להגדיר ערכי ברירת מחדל של פרמטרים באפליקציה באובייקט Remote Config. כך תוכלו לוודא שהאפליקציה תתנהג כמצופה גם אם היא לא תוכל לאחזר ערכים מהשירות Remote Config.

Swift

  1. במסוף Firebase, פותחים את Remote Config.

  2. בכרטיסייה פרמטרים, פותחים את התפריט ובוחרים באפשרות הורדת ערכי ברירת מחדל.

  3. כשמופיעה בקשה, מפעילים את .plist ל-iOS ולוחצים על הורדת הקובץ.

  4. שומרים את הקובץ בספריית האפליקציה.

    אם משתמשים באפליקציה לדוגמה, שומרים אותה בתוך FirebaseVertexAI/Sample/VertexAISample.

  5. ב-Xcode, לוחצים לחיצה ימנית על האפליקציה ובוחרים באפשרות Add Files (הוספת קבצים).

    אם משתמשים בדוגמה, לוחצים לחיצה ימנית על VertexAISample ובוחרים באפשרות הוספת קבצים אל VertexAISample.

  6. בוחרים באפשרות remote_config_defaults.plist ולוחצים על הוספה.

  7. מעדכנים את קוד האפליקציה כך שיפנה לקובץ ברירות המחדל:

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

Kotlin

  1. ממסוף Firebase, פותחים את Remote Config.

  2. בכרטיסייה פרמטרים, פותחים את התפריט ובוחרים באפשרות הורדת ערכי ברירת מחדל.

  3. כשמוצגת בקשה, מפעילים את האפשרות .xml for Android (קובץ XML ל-Android) ולוחצים על Download file (הורדת הקובץ).

  4. שומרים את הקובץ בספריית משאבי ה-XML של האפליקציה.

  5. מעדכנים את קובץ הפעילות הראשי כדי להוסיף את ברירות המחדל אחרי configSettings שהוספתם קודם:

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

Java

  1. במסוף Firebase, פותחים את Remote Config.

  2. בכרטיסייה פרמטרים, פותחים את התפריט ובוחרים באפשרות הורדת ערכי ברירת מחדל.

  3. כשמוצגת בקשה, מפעילים את האפשרות .xml for Android (קובץ XML ל-Android) ולוחצים על Download file (הורדת הקובץ).

  4. שומרים את הקובץ בספריית משאבי ה-XML של האפליקציה.

  5. מעדכנים את קובץ הפעילות הראשי כדי להוסיף את ברירות המחדל אחרי configSettings שהוספתם קודם:

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

Web

אפשר להגדיר את ערכי ברירת המחדל ישירות בקוד:

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

אפשר להגדיר את ערכי ברירת המחדל ישירות בקוד:

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

אפשר להגדיר את ערכי ברירת המחדל ישירות בקוד:

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

שלב 4: מאחזרים ומפעילים ערכים

אחרי שמגדירים ערכי ברירת מחדל, מוסיפים את הקוד הבא כדי לאחזר ולהפעיל את הערכים.

Swift 

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

הפעולה הזו אמורה לעדכן את האובייקט Remote Config בכל פעם שתבנית חדשה של 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. מוסיפים את getValue ואת fetchAndActivate לייבוא:

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

  2. אחרי הקוד שהוספתם כדי להגדיר ערכי ברירת מחדל של Remote Config, מאחזרים ומפעילים את ההגדרה, ואז מקצים ערכים לקבועים modelName,‏ systemInstructions,‏ prompt ו-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();

שלב 5: הוספת מאזין Remote Config בזמן אמת

כדי לוודא שהשינויים שאתם מבצעים בRemote Configתבנית יועברו ללקוח ברגע שהם יתעדכנו, צריך להוסיף לאפליקציה מאזין Remote Config בזמן אמת.

הקוד הבא מעדכן את האובייקט Remote Config בכל פעם שערך של פרמטר משתנה.

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

אופציונלי: אפשר גם להגדיר פעולה בתוך ההפעלה של 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

אופציונלי: אפשר גם להגדיר פעולה בתוך ההפעלה של 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

לא ניתן להשתמש במאזינים Remote Config בזמן אמת באפליקציות אינטרנט.

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

שלב 6: עדכון הבקשות של Gemini API לשימוש בערכים של Remote Config

לוחצים על הספק Gemini API כדי לראות בדף הזה תוכן וקוד שספציפיים לספק.

אחרי שסיימתם להגדיר את Remote Config, צריך לעדכן את הקוד כדי להחליף את הערכים שמוצפנים בקוד בערכים שמגיעים מ-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.");

שלב 7: מריצים את האפליקציה

מבצעים build ומריצים את האפליקציה כדי לוודא שהיא פועלת. מבצעים שינויים בהגדרה בדף Remote Config במסוף Firebase, מפרסמים את השינויים ומאמתים את התוצאה.

השלבים הבאים