מדריך RAG של AI Edge ל-Android

ה-AI Edge RAG SDK מספק את הרכיבים הבסיסיים ליצירת צינור עיבוד נתונים של יצירת נתונים משופרת לאחזור (RAG) באמצעות LLM Inference API. צינור עיבוד נתונים של RAG מספק ל-LLM גישה לנתונים שסופקו על ידי משתמשים, שיכולים לכלול מידע מעודכן, רגיש או ספציפי לדומיין. בעזרת יכולות אחזור המידע הנוספות של RAG, מודלים של שפה גדולה יכולים ליצור תשובות מדויקות יותר ומותאמות הקשר יותר בתרחישי שימוש ספציפיים.

במדריך הזה נסביר איך לבצע הטמעה בסיסית של אפליקציה לדוגמה באמצעות LLM Inference API עם AI Edge RAG SDK. המדריך הזה מתמקד ביצירת צינור עיבוד נתונים של RAG. למידע נוסף על השימוש ב-LLM Inference API, אפשר לעיין במדריך ל-LLM Inference ל-Android.

האפליקציה המלאה לדוגמה זמינה ב-GitHub. כדי להתחיל, מפתחים את האפליקציה, קוראים את הנתונים שהמשתמשים סיפקו (sample_context.txt) ושואלים את השאלות של LLM שקשורות למידע בקובץ הטקסט.

הרצת האפליקציה לדוגמה

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

האפליקציה מותאמת למכשירים מתקדמים יותר, כמו Pixel 8,‏ Pixel 9,‏ S23 ו-S24. מחברים מכשיר Android לתחנת העבודה ומוודאים שגרסת Android Studio עדכנית. מידע נוסף זמין במדריך ההתקנה ל-Android.

הורדת קוד האפליקציה

בהוראות הבאות מוסבר איך ליצור עותק מקומי של קוד הדוגמה באמצעות כלי שורת הפקודה של git.

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

git clone https://github.com/google-ai-edge/ai-edge-apis

אחרי שיוצרים גרסה מקומית של קוד הדוגמה, אפשר לייבא את הפרויקט ל-Android Studio ולהריץ את האפליקציה.

הורדת מודל

האפליקציה לדוגמה מוגדרת לשימוש ב-Gemma-3 1B. Gemma-3 1B הוא חלק ממשפחת Gemma של מודלים פתוחים וקלים, מתקדמים ביותר, שנוצרו על סמך אותו מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini. המודל מכיל מיליארד פרמטרים ומשקלים פתוחים.

הורדת Gemma-3 1B

אחרי שמורידים את Gemma-3 1B מ-Hugging Face, מעבירים את המודל למכשיר:

cd ~/Downloads
tar -xvzf gemma3-1b-it-int4.tar.gz

$ adb shell rm -r /data/local/tmp/llm/ # Remove any previously loaded models
$ adb shell mkdir -p /data/local/tmp/llm/
$ adb push output_path /data/local/tmp/llm/model_version.task

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

הגדרת גורם הטמעה

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

האפליקציה לדוגמה מיועדת לעבוד עם שני מקודדים מוטמעים, המקודד המוטמע של Gemini והקודד המוטמע של Gecko.

הגדרה באמצעות Gecko embedder

כברירת מחדל, האפליקציה לדוגמה מוגדרת להשתמש ב-Gecko embedder‏ (GeckoEmbeddingModel), והיא מפעילה את המודל במלואו במכשיר.

הורדת Gecko 110m-en

הכלי להטמעת Gecko זמין כמודלים של float ומודלים של quantized, עם כמה גרסאות לאורכים שונים של רצפים. מידע נוסף זמין בכרטיס הדגם של Gecko.

מפרטי המודל מופיעים בשם הקובץ של המודל. לדוגמה:

• Gecko_256_fp32.tflite: מודל של פלוט (float) שתומך ברצפים של עד 256 אסימונים.
• Gecko_1024_quant.tflite: מודל מדורג שתומך ברצפים של עד 1,024 אסימונים.

אורך הרצף הוא גודל הקטע המקסימלי שהמודל יכול להטמיע. לדוגמה, אם מועבר למדגם Gecko_256_fp32.tflite מקטע שחורג מאורך הרצף, הוא יטמיע את 256 האסימונים הראשונים ויחתוך את שאר המקטע.

מעבירים את מודל המפַתח (sentencepiece.model) ואת הכלי להטמעת Gecko למכשיר:

adb push sentencepiece.model /data/local/tmp/sentencepiece.model
adb push Gecko_256_fp32.tflite /data/local/tmp/gecko.tflite

מודל ההטמעה תואם גם למעבדים (CPU) וגם למעבדים גרפיים (GPU). כברירת מחדל, האפליקציה לדוגמה מוגדרת לחלץ הטמעות (embeddings) באמצעות מודל Gecko ב-GPU.

companion object {
  ...
  private const val USE_GPU_FOR_EMBEDDINGS = true
}

הגדרה באמצעות Gemini Embedder

הכלי להטמעת Gemini (GeminiEmbedder) יוצר הטמעות באמצעות Gemini Cloud API. כדי להריץ את האפליקציה, צריך מפתח API של Google Gemini. אפשר לקבל אותו בדף ההגדרה של Google Gemini API.

קבלת מפתח Gemini API ב-Google AI Studio

מוסיפים את מפתח ה-API של Gemini ומגדירים את COMPUTE_EMBEDDINGS_LOCALLY כ-false בקובץ RagPipeline.kt:

companion object {
  ...
  private const val COMPUTE_EMBEDDINGS_LOCALLY = false
  private const val GEMINI_API_KEY = "<API_KEY>"
}

איך זה עובד

בקטע הזה מפורט מידע נוסף על הרכיבים של צינור עיבוד הנתונים של RAG באפליקציה. רוב הקוד מופיע בקובץ RagPipeline.kt.

יחסי תלות

ערכת ה-SDK של RAG משתמשת בספרייה com.google.ai.edge.localagents:localagents-rag. מוסיפים את יחסי התלות האלה לקובץ build.gradle של אפליקציית Android:

dependencies {
    ...
    implementation("com.google.ai.edge.localagents:localagents-rag:0.1.0")
    implementation("com.google.mediapipe:tasks-genai:0.10.22")
}

פרטים שהמשתמשים סיפקו

הנתונים שהמשתמשים סיפקו באפליקציה הם קובץ טקסט בשם sample_context.txt, שנשמר בספרייה assets. האפליקציה מקבלת קטעי טקסט מקובץ הטקסט, יוצרת הטמעות של הקטעים האלה ומפנה להטמעות האלה בזמן יצירת טקסט הפלט.

קטע הקוד הבא נמצא בקובץ MainActivity.kt:

class MainActivity : ComponentActivity() {
  lateinit var chatViewModel: ChatViewModel
...
    chatViewModel.memorizeChunks("sample_context.txt")
...
}

חלוקה לקטעים

כדי לפשט את התהליך, הקובץ sample_context.txt כולל תגי <chunk_splitter> שבהם האפליקציה לדוגמה משתמשת כדי ליצור קטעים. לאחר מכן נוצרים הטמעות לכל מקטע. באפליקציות ייצור, גודל הקטעים הוא שיקול חשוב. אם הרצף גדול מדי, הווקטור לא מכיל מספיק פרטים כדי להיות שימושי. אם הוא קטן מדי, הוא לא מכיל מספיק הקשר.

האפליקציה לדוגמה מטפלת בחלוקה לקטעים באמצעות הפונקציה memorizeChunks ב-RagPipeline.kt.

הטמעה

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

• Gecko embedder: חילוץ מקומי (במכשיר) של הטמעת טקסט באמצעות מודל Gecko.
• Gemini Embedder: חילוץ הטמעת טקסט מבוססת-ענן באמצעות Generative Language Cloud API.

האפליקציה לדוגמה בוחרת את ה-embedder על סמך האפשרות שהמשתמש רוצה לחשב את הטמעות הנתונים באופן מקומי או דרך Google Cloud. קטע הקוד הבא נמצא בקובץ RagPipeline.kt:

private val embedder: Embedder<String> = if (COMPUTE_EMBEDDINGS_LOCALLY) {
  GeckoEmbeddingModel(
    GECKO_MODEL_PATH,
    Optional.of(TOKENIZER_MODEL_PATH),
    USE_GPU_FOR_EMBEDDINGS,
    )
  } else {
    GeminiEmbedder(
      GEMINI_EMBEDDING_MODEL,
      GEMINI_API_KEY
      )
  }

מסד נתונים

באפליקציית הדוגמה נעשה שימוש ב-SQLite‏ (SqliteVectorStore) כדי לאחסן הטמעות של טקסט. אפשר גם להשתמש במסד הנתונים DefaultVectorStore לאחסון וקטורים לא עמידים.

קטע הקוד הבא נמצא בקובץ RagPipeline.kt:

private val config = ChainConfig.create(
    mediaPipeLanguageModel, PromptBuilder(QA_PROMPT_TEMPLATE1),
    DefaultSemanticTextMemory(
        SqliteVectorStore(768), embedder
    )
)

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

Chain

ערכת ה-SDK של RAG מספקת שרשראות, שמשלבות כמה רכיבים של RAG בצינור עיבוד נתונים אחד. אפשר להשתמש בשרשורים כדי לתזמור מודלים של אחזור ושאילתות. ה-API מבוסס על הממשק Chain.

באפליקציה לדוגמה נעשה שימוש בשרשרת אחזור והסקה. קטע הקוד הבא נמצא בקובץ RagPipeline.kt:

private val retrievalAndInferenceChain = RetrievalAndInferenceChain(config)

השרשרת מופעלת כשהמודל יוצר תשובות:

suspend fun generateResponse(
    prompt: String,
    callback: AsyncProgressListener<LanguageModelResponse>?
): String =
    coroutineScope {
        val retrievalRequest =
            RetrievalRequest.create(
                prompt,
                RetrievalConfig.create(2, 0.0f, TaskType.QUESTION_ANSWERING)
            )
        retrievalAndInferenceChain.invoke(retrievalRequest, callback).await().text
    }