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

תרחישים לדוגמה לשימוש ב-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 חדשה, בודקים את השינויים ולוחצים שוב על Publish changes (פרסום השינויים).

שלב 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, מפרסמים את השינויים ומאמתים את התוצאה.

השלבים הבאים