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

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

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

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

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

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

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

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

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

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

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

  • שדרוג לגרסה האחרונה של המודל בלי עדכון האפליקציה: משתמשים בפרמטרים 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 באפליקציות ל-iOS, ל-Android ול-Flutter כדי לבדוק שינויים בפרמטרים של AI גנרטיבי בפלחים שונים של משתמשים, ולראות איך הם משפיעים על מדדים מרכזיים כמו שימור משתמשים והכנסות.

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

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

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

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

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

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

  • מסיימים את המדריך לתחילת העבודה עם ה-SDK של Vertex AI in Firebase. חשוב לוודא שכל הפעולות הבאות בוצעו:

    1. מגדירים פרויקט Firebase חדש או קיים, כולל שימוש בתוכנית התמחור Blaze והפעלה של ממשקי ה-API הנדרשים.
    2. מקשרים את האפליקציה ל-Firebase, כולל רישום האפליקציה והוספת ההגדרות של Firebase לאפליקציה.
    3. מוסיפים את ה-SDK ומפעילים את שירות Vertex AI ואת המודל הגנרטיבי באפליקציה.

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

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

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

  1. פותחים את פרויקט Firebase במסוף Firebase, מרחיבים את האפשרות Run בתפריט הניווט ובוחרים באפשרות Remote Config.
  2. מוודאים שהאפשרות Client מסומנת בבורר Client/Server בחלק העליון של הדף Remote Config.
    • אם זו הפעם הראשונה שאתם משתמשים בתבניות לקוח של Remote Config, לוחצים על Create Configuration. החלונית Create your first parameter מופיעה.
    • אם זו לא הפעם הראשונה שאתם משתמשים בתבניות Remote Config, לוחצים על Add parameter.

  3. מגדירים את הפרמטרים הבאים של Remote Config:

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

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

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

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

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

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

בדוגמה הזו, מרווח האחזור שמוגדר כברירת מחדל הוא 3,600 שניות, אבל מומלץ להגדיר מרווח אחזור מינימלי נמוך יחסית בקוד במהלך הפיתוח.

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

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

  1. במסוף Firebase, פותחים את Remote Config.
  2. בכרטיסייה Parameters, פותחים את Menu ובוחרים באפשרות Download default values.
  3. כשמוצגת בקשה, מפעילים את האפשרות קובץ XML ל-Android ולוחצים על הורדת הקובץ.
  4. שומרים את הקובץ בתיקיית המשאבים של ה-XML באפליקציה.

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

    Kotlin+KTX 

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

    Java 

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

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

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

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

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

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

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

שלב 6: הקצאת ערכים של Remote Config למשתני Vertex AI

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

מחליפים את הערכים הקבועים של המיקום, שם הדגם, הוראות המערכת וההנחיה למשתמש בערכים שמקורם ב-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);

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

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

השלבים הבאים