Android के लिए एआई एज एजेंसी रेटिंग गाइड

AI Edge RAG SDK, एलएलएम इन्फ़रेंस एपीआई के साथ, रीट्रिवल ऑगमेंटेड जनरेशन (आरएजी) पाइपलाइन बनाने के लिए बुनियादी कॉम्पोनेंट उपलब्ध कराता है. आरएजी पाइपलाइन, एलएलएम को उपयोगकर्ता से मिले डेटा का ऐक्सेस देती है. इसमें अपडेट की गई, संवेदनशील या डोमेन के हिसाब से जानकारी शामिल हो सकती है. आरएजी से जानकारी पाने की बेहतर सुविधाओं की मदद से, एलएलएम खास इस्तेमाल के उदाहरणों के लिए ज़्यादा सटीक और संदर्भ के हिसाब से जवाब जनरेट कर सकते हैं.

इस गाइड में, एआई एज आरएजी एसडीके के साथ एलएलएम इन्फ़्रेंस एपीआई का इस्तेमाल करके, सैंपल ऐप्लिकेशन को लागू करने का बुनियादी तरीका बताया गया है. इस गाइड में, RAG पाइपलाइन बनाने के बारे में बताया गया है. एलएलएम इन्फ़रेंस एपीआई का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, Android के लिए एलएलएम इन्फ़रेंस गाइड देखें.

पूरा सैंपल ऐप्लिकेशन GitHub पर देखा जा सकता है. शुरू करने के लिए, ऐप्लिकेशन बनाएं. इसके बाद, उपयोगकर्ता से मिले डेटा (sample_context.txt) को पढ़ें. साथ ही, एलएलएम से टेक्स्ट फ़ाइल में मौजूद जानकारी से जुड़े सवाल पूछें.

उदाहरण के तौर पर दिए गए ऐप्लिकेशन को चलाना

इस गाइड में, Android के लिए RAG की सुविधा वाले टेक्स्ट जनरेशन ऐप्लिकेशन का उदाहरण दिया गया है. अपने 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 मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. इस मॉडल में 100 करोड़ पैरामीटर हैं और इसके वेट ओपन सोर्स हैं.

Gemma-3 1B डाउनलोड करें

Hugging Face से Gemma-3 1B डाउनलोड करने के बाद, मॉडल को अपने डिवाइस पर पुश करें:

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

सैंपल ऐप्लिकेशन के साथ अन्य मॉडल भी इस्तेमाल किए जा सकते हैं. हालांकि, इसके लिए आपको कॉन्फ़िगरेशन के अतिरिक्त चरण पूरे करने पड़ सकते हैं.

वीडियो एम्बेड करने की सुविधा देने वाली कंपनी के तौर पर सेट अप करना

एम्बेडर, उपयोगकर्ता से मिले डेटा से टेक्स्ट के बड़े हिस्से लेता है और उन्हें वेक्टर वाले न्यूमेरिक फ़ॉर्मैट में बदलता है. इससे टेक्स्ट का सिमैंटिक मतलब पता चलता है. एलएलएम, काम के वेक्टर की पहचान करने के लिए इन एम्बेडिंग का इस्तेमाल करता है. साथ ही, जनरेट किए गए आउटपुट में, सिमैंटिक तौर पर सबसे ज़्यादा काम के चंक शामिल करता है.

सैंपल ऐप्लिकेशन को दो एम्बेडर के साथ काम करने के लिए डिज़ाइन किया गया है: Gemini एम्बेडर और Gecko एम्बेडर.

Gecko एम्बेडर की मदद से सेट अप करना

डिफ़ॉल्ट रूप से, सैंपल ऐप्लिकेशन को Gecko embedder (GeckoEmbeddingModel) का इस्तेमाल करने के लिए कॉन्फ़िगर किया जाता है. साथ ही, यह मॉडल को पूरी तरह से डिवाइस पर चलाता है.

Download Gecko 110m-en

Gecko एम्बेडर, फ़्लोट और क्वांटाइज़्ड मॉडल के तौर पर उपलब्ध है. साथ ही, यह अलग-अलग सीक्वेंस की लंबाई के लिए कई वर्शन में उपलब्ध है. ज़्यादा जानकारी के लिए, Gecko मॉडल कार्ड देखें.

मॉडल के स्पेसिफ़िकेशन, मॉडल के फ़ाइल नाम में देखे जा सकते हैं. उदाहरण के लिए:

• Gecko_256_f32.tflite: फ़्लोट मॉडल, जो 256 टोकन तक के क्रम के साथ काम करता है.
• Gecko_1024_quant.tflite: यह एक क्वांटाइज़्ड मॉडल है. यह ज़्यादा से ज़्यादा 1,024 टोकन वाले सीक्वेंस के साथ काम करता है.

सीक्वेंस की लंबाई, मॉडल के एम्बेड किए जा सकने वाले ज़्यादा से ज़्यादा चंक का साइज़ होती है. उदाहरण के लिए, अगर Gecko_256_f32.tflite मॉडल को ऐसा हिस्सा दिया जाता है जिसकी लंबाई, क्रम की लंबाई से ज़्यादा है, तो मॉडल पहले 256 टोकन को एम्बेड करेगा और बाकी हिस्से को छोटा कर देगा.

टोकनाइज़र मॉडल (sentencepiece.model) और Gecko एम्बेडर को अपने डिवाइस पर पुश करें:

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

एम्बेड करने वाला मॉडल, सीपीयू और जीपीयू, दोनों के साथ काम करता है. डिफ़ॉल्ट रूप से, सैंपल ऐप्लिकेशन को जीपीयू पर Gecko मॉडल की मदद से एम्बेडिंग निकालने के लिए कॉन्फ़िगर किया जाता है.

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

Gemini Embedder की मदद से सेट अप करना

Gemini Embedder (GeminiEmbedder), Gemini Cloud API का इस्तेमाल करके एम्बेडिंग बनाता है. इस ऐप्लिकेशन को चलाने के लिए, Google Gemini API पासकोड की ज़रूरत होती है. इसे Google Gemini API के सेटअप पेज से पाया जा सकता है.

Google AI Studio में Gemini API पासकोड पाना

RagPipeline.kt में अपना Gemini API पासकोड जोड़ें और COMPUTE_EMBEDDINGS_LOCALLY को false पर सेट करें:

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

यह कैसे काम करता है

इस सेक्शन में, ऐप्लिकेशन के RAG पाइपलाइन कॉम्पोनेंट के बारे में ज़्यादा जानकारी दी गई है. ज़्यादातर कोड को RagPipeline.kt पर देखा जा सकता है.

डिपेंडेंसी

RAG SDK, com.google.ai.edge.localagents:localagents-rag लाइब्रेरी का इस्तेमाल करता है. अपने Android ऐप्लिकेशन की build.gradle फ़ाइल में यह डिपेंडेंसी जोड़ें:

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 का इस्तेमाल करता है.

सैंपल ऐप्लिकेशन, एम्बेडर को इस आधार पर चुनता है कि उपयोगकर्ता को एम्बेडिंग की गणना स्थानीय तौर पर करनी है या 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 पर सेट करता है. इसका मतलब है कि वेक्टर डेटाबेस में हर वेक्टर की लंबाई 768 है.

चेन

RAG SDK, चेन उपलब्ध कराता है. ये चेन, RAG के कई कॉम्पोनेंट को एक पाइपलाइन में जोड़ती हैं. चेन का इस्तेमाल, मॉडल से जानकारी पाने और क्वेरी करने के लिए किया जा सकता है. यह एपीआई, Chain इंटरफ़ेस पर आधारित है.

सैंपल ऐप्लिकेशन, Retrieval and Inference 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
    }