लैंग्वेज मॉडल

Prompt API की मदद से, डेवलपर Gemini Nano का इस्तेमाल करके, सीधे ब्राउज़र में नैचुरल लैंग्वेज प्रोसेसिंग टास्क चला सकते हैं. पहले से मौजूद एआई की मदद से, उपयोगकर्ता की निजता को सुरक्षित रखा जाता है, सर्वर की लागत कम की जाती है, और ऑफ़लाइन काम करने की सुविधा मिलती है.

1. शुरू करने और हार्डवेयर से जुड़ी ज़रूरी शर्तें

फ़िलहाल, Prompt API, Chrome के वर्शन 148 (डेस्कटॉप) में उपलब्ध है. यह Windows, macOS, Linux, और Chromebook Plus पर काम करता है.

हार्डवेयर से जुड़ी ज़रूरी शर्तें

• स्टोरेज: 22 जीबी खाली स्टोरेज (शुरुआती प्रोफ़ाइल और मॉडल के लिए).
• मेमोरी/सीपीयू: 16 जीबी रैम और चार या इससे ज़्यादा सीपीयू कोर.
• जीपीयू: 4 जीबी वीआरएएम या इससे ज़्यादा (ऑडियो इनपुट के लिए ज़रूरी है).
• नेटवर्क: इसकी ज़रूरत सिर्फ़ शुरुआती मॉडल को डाउनलोड करने के लिए होती है.

एपीआई को शुरू करना

डाउनलोड ट्रिगर करने से पहले, देखें कि मॉडल उपलब्ध है या नहीं:

const availability = await LanguageModel.availability();

// Do not call create() when unavailable — the model cannot run on this device.
if (availability !== 'unavailable') {
    const session = await LanguageModel.create({
        monitor(m) {
            // Inform the user while the model downloads so the UI doesn't appear frozen.
            m.addEventListener('downloadprogress', (e) => {
                console.log(`Downloaded ${e.loaded * 100}%`);
            });
        },
    });
}

2. प्रॉम्प्ट देने की मुख्य सुविधाएं

इस सेक्शन में दिए गए सेशन के उदाहरणों में, session.destroy() को शामिल नहीं किया गया है, ताकि उन्हें कम शब्दों में समझाया जा सके. जब डिवाइस की मेमोरी खाली करने के लिए किसी सेशन की ज़रूरत न हो, तो हमेशा session.destroy() को कॉल करें (सेक्शन 5 देखें).

बेसिक और स्ट्रीम किया गया आउटपुट

कम शब्दों में जवाब पाने के लिए, prompt() का इस्तेमाल करें. ज़्यादा लंबे कॉन्टेंट के लिए, promptStreaming() का इस्तेमाल करें. इससे यूज़र इंटरफ़ेस (यूआई) ज़्यादा रिस्पॉन्सिव बनता है.

ज़रूरी: मॉडल आउटपुट को कभी भी innerHTML के तौर पर असाइन न करें. मॉडल आउटपुट भरोसेमंद नहीं है और इसमें इंजेक्ट किया गया मार्कअप हो सकता है. हमेशा textContent या सैनिटाइज़र का इस्तेमाल करें.

const session = await LanguageModel.create();

// prompt() accumulates the full response before resolving — use for short, one-shot output.
const result = await session.prompt('Write a haiku about coding.');
// textContent, not innerHTML — model output is untrusted and must not be parsed as markup.
outputEl.textContent = result;

// promptStreaming() yields independent chunks that must be concatenated;
// use for longer content so each chunk can be rendered progressively.
const stream = session.promptStreaming('Write a long story about a robot.');
let completeResult = '';
for await (const chunk of stream) {
    completeResult += chunk;
    outputEl.append(chunk);
}
console.log('Full story:', completeResult);

मल्टीमॉडल इनपुट

Prompt API में टेक्स्ट, ऑडियो, और विज़ुअल इनपुट (इमेज, कैनवस, वीडियो फ़्रेम) इस्तेमाल किए जा सकते हैं.

const session = await LanguageModel.create({
    // Declaring expected input types lets the browser optimize model loading.
    expectedInputs: [{ type: 'text' }, { type: 'image' }],
    expectedOutputs: [{ type: 'text' }],
});

const response = await session.prompt([
    {
        role: 'user',
        content: [
            { type: 'text', value: 'What is in this image?' },
            { type: 'image', value: document.querySelector('canvas') },
        ],
    },
]);

3. ऐडवांस सेशन मैनेजमेंट

सेशन की मदद से, मॉडल कई इंटरैक्शन के दौरान कॉन्टेक्स्ट को बनाए रख सकता है.

कॉन्टेक्स्ट और कोटा

हर सेशन के लिए, टोकन की एक तय सीमा होती है. session.contextUsage और session.contextWindow की मदद से, इस्तेमाल पर नज़र रखी जा सकती है. अगर विंडो ओवरफ़्लो हो जाती है, तो सबसे पुराने मैसेज हटा दिए जाते हैं. हालांकि, सिस्टम प्रॉम्प्ट को नहीं हटाया जाता.

क्लोन करने के सेशन

क्लोन करने की सुविधा, एक ही शुरुआती कॉन्टेक्स्ट (जैसे, "सिस्टम" पर्सनैलिटी) वाली बातचीत को फिर से शुरू किए बिना, एक साथ कई बातचीत शुरू करने के लिए कारगर है.

const mainSession = await LanguageModel.create({
    initialPrompts: [{ role: 'system', content: 'You speak like a pirate.' }],
});

const branchA = await mainSession.clone();
const branchB = await mainSession.clone();
// Destroy the base after cloning — the clones own their own context from here.
mainSession.destroy();

पिछले सेशन को वापस लाना

फ़िलहाल, "रीस्टोर" करने की सुविधा पर काम चल रहा है. हालांकि, initialPrompts में पिछला इतिहास डालकर, सेशन को फिर से बनाया जा सकता है.

ध्यान दें: localStorage को एन्क्रिप्ट (सुरक्षित) नहीं किया गया है और यह हमेशा मौजूद रहता है. सेव की गई बातचीत के इतिहास में, उपयोगकर्ता की व्यक्तिगत पहचान से जुड़ी जानकारी (पीआईआई) शामिल हो सकती है. इसलिए, चैट का इतिहास सेव करने से पहले, निजता से जुड़े असर पर विचार करें.

// || '[]' ensures JSON.parse never receives null when the key doesn't exist yet.
const history = JSON.parse(localStorage.getItem('chat_history') || '[]');
const session = await LanguageModel.create({
    initialPrompts: history, // Array of {role, content} objects
});

4. JSON स्कीमा के साथ स्ट्रक्चर्ड आउटपुट

मॉडल को "चैट" (उदाहरण के लिए, "ज़रूर, यह रहा आपका JSON:") जोड़ने से रोकने के लिए, responseConstraint फ़ील्ड के ज़रिए JSON स्कीमा का इस्तेमाल करें. इससे यह पक्का होता है कि आउटपुट मान्य JSON फ़ॉर्मैट में हो, ताकि उसे तुरंत पार्स किया जा सके.

उदाहरण: सेंटिमेंट क्लासिफ़िकेशन

// Pass the schema as a plain object — do not JSON.stringify() it first.
const schema = {
    type: 'object',
    properties: {
        rating: { type: 'number', minimum: 1, maximum: 5 },
        is_positive: { type: 'boolean' },
    },
    required: ['rating', 'is_positive'],
};

const result = await session.prompt(
    "Rate the following feedback: 'The food was great!'",
    { responseConstraint: schema },
);

const data = JSON.parse(result);
console.log(data.rating); // 5

पाबंदियां और प्रीफ़िक्स

prefix: true का इस्तेमाल करके, असिस्टेंट के जवाब को पहले से भरकर, मॉडल को और बेहतर तरीके से निर्देश दिया जा सकता है.

const character = await session.prompt([
    { role: 'user', content: 'Create a character sheet' },
    { role: 'assistant', content: '```json\n', prefix: true },
]);

5. सबसे सही तरीके और सुरक्षा

• संसाधन खाली करना: बातचीत खत्म होने पर, मेमोरी खाली करने के लिए हमेशा session.destroy() को कॉल करें.
• आउटपुट की सुरक्षा: मॉडल आउटपुट भरोसेमंद नहीं है. नुकसान पहुंचाने वाले मॉडल आउटपुट से XSS इंजेक्शन को रोकने के लिए, नतीजों को हमेशा textContent में लिखें, न कि innerHTML में.
• अगर आपको सीमित एचटीएमएल की अनुमति देनी है, तो नेटिव सैनिटाइज़र एपीआई या DOMPurify जैसे सैनिटाइज़र का इस्तेमाल करें.
• टास्क रद्द करना: AbortController का इस्तेमाल करके, उपयोगकर्ताओं को लंबे समय से चल रहे जनरेशन को रोकने की अनुमति दें. signal को prompt() या promptStreaming() को पास करें, LanguageModel.create() को नहीं.
• सुरक्षा: iframe में ऐक्सेस को कंट्रोल करने के लिए, अनुमति से जुड़ी नीतियों का इस्तेमाल करें: <iframe src="..." allow="language-model"></iframe>.
• डिज़ाइन: एआई का ज़िम्मेदारी से इस्तेमाल करने के लिए, People + AI Guidebook देखें.

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

क्या करें और क्या न करें

क्या करें और क्या न करें, इसकी पूरी जानकारी पाने के लिए, https://developer.chrome.com/docs/ai/built-in-ai-dos-donts.md.txt पर जाएं. इसकी खास जानकारी यहां दी गई है:

मॉडल को सही समय पर तैयार करना

इन पर लागू होता है: सभी एपीआई. उदाहरण के लिए, Summarizer, Translator, और Writer.

क्या करें: जैसे ही आपको पता चले कि उपयोगकर्ता को एआई की सुविधा इस्तेमाल करनी है, सेशन शुरू कर दें. उदाहरण के लिए, जब कोई उपयोगकर्ता एआई टूल के किसी काम के प्लैटफ़ॉर्म पर जाता है, एआई वर्कस्पेस पर कर्सर घुमाता है या सुविधा के आस-पास मौजूद यूज़र इंटरफ़ेस (यूआई) से इंटरैक्ट करता है. सेशन को पहले से वॉर्म-अप करने से, मॉडल बैकग्राउंड में मेमोरी में लोड हो जाता है. ऐसा तब होता है, जब उपयोगकर्ता अपना टास्क सेट अप कर रहा होता है. इससे, कोल्ड-स्टार्ट लेटेंसी को कम किया जा सकता है. मौजूदा नतीजे को रेंडर करना शुरू करते ही, अगले सबसे संभावित एआई टास्क को शुरू करके, एक कदम आगे रहने की कोशिश करें. उदाहरण के लिए, अगर सुविधा को बार-बार इस्तेमाल करने के लिए डिज़ाइन किया गया है.

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

Gem बनाते समय शुरुआती प्रॉम्प्ट सेट करना

इन पर लागू होता है: Prompt API.

क्या करें: सेशन शुरू करते समय सिस्टम से जुड़े निर्देश दें, ताकि पहले प्रॉम्प्ट का जवाब तेज़ी से मिल सके.

क्या न करें: खाली सेशन से शुरुआत न करें और पहले prompt() कॉल के हिस्से के तौर पर सिस्टम से जुड़े निर्देश न भेजें. इससे इंतज़ार का समय बढ़ जाता है, क्योंकि मॉडल को आखिरी समय पर उन निर्देशों को प्रोसेस करना पड़ता है.

बार-बार किए जाने वाले टास्क के लिए सेशन क्लोन करना

इन पर लागू होता है: Prompt API.

Prompt API के लिए, हर सेशन बातचीत के संदर्भ को ट्रैक करता है. इसके लिए, वह पिछले सभी इंटरैक्शन को ध्यान में रखता है. क्लोन किए गए सेशन में, पैरंट सेशन की सभी चीज़ें इनहेरिट होती हैं. इनमें शुरुआती प्रॉम्प्ट और क्लोन किए जाने तक की सभी इंटरैक्शन हिस्ट्री शामिल है. इसलिए, सेशन को इस तरह से इस्तेमाल करें कि सिर्फ़ वही चीज़ें इनहेरिट हों जिनकी आपको ज़रूरत है.

यह करें:

• एक बुनियादी सेशन बनाएं: अलग-अलग टास्क को बेहतर तरीके से मैनेज करने के लिए, एक बुनियादी सेशन बनाएं. इसमें सिर्फ़ सिस्टम से जुड़े निर्देश शामिल करें और पिछली बातचीत का कोई कॉन्टेक्स्ट शामिल न करें.
• बेसलाइन को क्लोन करना: नए टास्क के लिए, उस बेस सेशन पर clone() का इस्तेमाल करें. इससे सिस्टम के निर्देशों को फिर से पार्स करने का ओवरहेड कम हो जाता है. इससे आपको एक साथ कई बातचीत करने या किसी टास्क को उसकी बेसलाइन पर रीसेट करने की सुविधा मिलती है.

क्या न करें:

• एक ही सेशन का इस्तेमाल, अलग-अलग कामों के लिए न करें. साथ ही, ऐसे किसी भी सेशन को क्लोन करने से बचें जिसमें पहले से ही ग़ैर-ज़रूरी इंटरैक्शन का इतिहास मौजूद हो. इन दोनों पैटर्न की वजह से, पिछली बातचीत का ऐसा कॉन्टेक्स्ट आपके मौजूदा टास्क में शामिल हो सकता है जो उससे जुड़ा न हो.
• एक जैसे सिस्टम निर्देशों के साथ create() को बार-बार कॉल न करें. परफ़ॉर्मेंस को ऑप्टिमाइज़ करने के लिए, क्लोनिंग पैटर्न का इस्तेमाल करें.

इस्तेमाल नहीं किए गए सेशन मिटाना

इन पर लागू होता है: सभी एपीआई.

क्या करें: जिन सेशन की अब ज़रूरत नहीं है उनके लिए destroy() को साफ़ तौर पर कॉल करें. इससे, किसी सुविधा का इस्तेमाल न होने पर मेमोरी खाली हो जाएगी. अगर क्लोनिंग पैटर्न का इस्तेमाल किया जाता है, तो बेस सेशन को बनाए रखें और उन क्लोन को मिटा दें जिनकी अब ज़रूरत नहीं है.

क्या न करें: एक साथ कई बड़े सेशन चालू न रखें. हर सेशन मेमोरी का इस्तेमाल करता है. इससे संसाधनों का ग़ैर-ज़रूरी इस्तेमाल होता है और समस्या हो सकती है. गार्बेज कलेक्टर, सेशन को अपने-आप हटा देगा. हालांकि, destroy() को कॉल करने से मेमोरी ज़्यादा तेज़ी से खाली होती है.

स्ट्रीमिंग रिस्पॉन्स को सुरक्षित और असरदार तरीके से रेंडर करना

लागू होने की जानकारी: स्ट्रीमिंग की सुविधा वाले सभी एपीआई (प्रॉम्प्ट, खास जानकारी देने वाला, लिखने वाला, फिर से लिखने वाला, और अनुवाद करने वाला).

क्या करें: एलएलएम से मिले सभी आउटपुट को अविश्वसनीय कॉन्टेंट मानें. सिर्फ़ कुछ हिस्सों को नहीं, बल्कि पूरे आउटपुट को सैनिटाइज़ करें. ऐसा इसलिए, क्योंकि नुकसान पहुंचाने वाला कोड, अलग-अलग अपडेट में बंटा हो सकता है. रेंडर करने से पहले, जहां भी हो सके वहां Sanitizer API का इस्तेमाल करें. परफ़ॉर्मेंस में गिरावट से बचने के लिए, streaming-markdown जैसे स्ट्रीमिंग मार्कडाउन पार्सर का इस्तेमाल करें.

यह न करें: हर चंक अपडेट पर सीधे innerHTML सेट करें. यह प्रोसेस धीमी है. खास तौर पर, सिंटैक्स हाइलाइट करने जैसी जटिल फ़ॉर्मैटिंग के साथ. साथ ही, इसमें इंजेक्शन का खतरा भी होता है.

तेज़ी से इनपुट देने के लिए ऑप्टिमाइज़ करना

इन पर लागू होता है: सभी एपीआई.

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

क्या न करें: एपीआई को रॉ अनप्रोसेस्ड टेक्स्ट, ग़ैर-ज़रूरी मेटाडेटा, एचटीएमएल टैग या फ़िल्टर न की गई बड़ी सूचियां न भेजें. इनपुट का साइज़ बढ़ने के साथ-साथ, इंतज़ार का समय भी काफ़ी बढ़ जाता है. इस वजह से, कई डिवाइसों पर एआई की सुविधा काम नहीं करती.

अनुमानित नतीजे पाने के लिए, स्ट्रक्चर्ड आउटपुट का इस्तेमाल करना

इन पर लागू होता है: Prompt API.

क्या करें: जब आपको मॉडल से किसी खास फ़ॉर्मैट में डेटा चाहिए, तो स्ट्रक्चर्ड आउटपुट का इस्तेमाल करें. इसके लिए, JSON स्कीमा उपलब्ध कराने के लिए responseConstraint फ़ील्ड का इस्तेमाल करें. इससे यह पक्का होता है कि आउटपुट का अनुमान लगाया जा सकता है. साथ ही, आपको पोस्ट-प्रोसेसिंग या मैन्युअल पार्सिंग की ज़रूरत नहीं पड़ती.

क्या न करें: सिर्फ़ नैचुरल लैंग्वेज में दिए गए निर्देशों (जैसे, "सिर्फ़ JSON आउटपुट") पर भरोसा न करें. मॉडल में बातचीत के दौरान इस्तेमाल होने वाले ऐसे फ़िलर शामिल हो सकते हैं जो आपके पार्सर को ब्रेक करते हैं.

लंबाई की पाबंदियों से जनरेशन को अलग करना

यह Prompt API पर लागू होता है, क्योंकि सिर्फ़ यही एपीआई स्ट्रक्चर्ड आउटपुट स्कीमा के साथ काम करता है.

क्या करें: मॉडल को सामान्य तरीके से जवाब जनरेट करने दें. इसके बाद, क्लाइंट-साइड लॉजिक का इस्तेमाल करके, टेक्स्ट को अपने यूज़र इंटरफ़ेस (यूआई) के हिसाब से छोटा करें.

क्या न करें: स्ट्रक्चर्ड आउटपुट स्कीमा का इस्तेमाल करके, maxLength: 125 जैसी वर्ण सीमाएं लागू न करें. जब किसी मॉडल का जवाब आपकी सेट की गई सीमा से ज़्यादा लंबा होता है, तो हो सकता है कि मॉडल, जवाब को छोटा करने के लिए हाई-डेंसिटी टोकन पर स्विच कर जाए. जैसे, विदेशी भाषाएं या इमोजी. इससे जवाब का कोई मतलब नहीं निकलता.

उपयोगकर्ता को जानकारी देते रहना

इन पर लागू होता है: सभी एपीआई.

क्या करें: टास्क कितना मुश्किल है और उसे पूरा होने में कितना समय लग सकता है, इसके आधार पर ऐनिमेशन, विज़ुअल क्यू, और प्रोग्रेस इंडिकेटर का इस्तेमाल करें. इससे उपयोगकर्ता को टास्क की प्रोग्रेस के बारे में जानकारी मिलती रहेगी. सबसे सही तरीका, आपके इस्तेमाल के उदाहरण और एपीआई आउटपुट की अनुमानित लंबाई पर निर्भर करता है. यहां कुछ आइडिया दिए गए हैं:

• लंबे कॉन्टेंट के लिए स्ट्रीमिंग: खास जानकारी या चैट के लिए, स्ट्रीमिंग डिफ़ॉल्ट रूप से हर टोकन के लिए टाइपराइटर इफ़ेक्ट बनाती है. इससे बातचीत नैचुरल लगती है और तुरंत जवाब मिलता है.
• छोटे टास्क (या लंबे एसिंक्रोनस टास्क) के लिए नॉन-स्ट्रीमिंग: छोटे आउटपुट के लिए, जैसे कि वैकल्पिक टेक्स्ट, नॉन-स्ट्रीमिंग से ज़्यादा बेहतर यूज़र इंटरफ़ेस (यूआई) बनाया जा सकता है. इससे मौजूदा एआई टास्क को रेंडर करते समय, अगले एआई टास्क को तैयार करने का समय भी मिलता है. यह तरीका, लंबे समय तक चलने वाले एसिंक्रोनस या बैकग्राउंड टास्क के लिए भी काम करता है. अगर उपयोगकर्ता को अपनी यात्रा जारी रखने के लिए आउटपुट पर ब्लॉक नहीं किया गया है, तो आउटपुट को तुरंत जनरेट करने की ज़रूरत नहीं है. यूज़र इंटरफ़ेस (यूआई) में यह सिग्नल देना कि प्रोसेस जारी है.
• अपडेट के लिए विज़ुअल ट्रांज़िशन: टेक्स्ट का अनुवाद करते समय या उसे फिर से लिखते समय, ऐनिमेशन का इस्तेमाल करें. उदाहरण के लिए, वर्ड-मॉर्फ़िंग.

क्या न करें: विज़ुअल क्यू के बिना यूज़र इंटरफ़ेस (यूआई) को अपडेट न करें.

समय और काम के बारे में उपयोगकर्ता के मेंटल मॉडल के साथ अलाइन करना

इन पर लागू होता है: सभी एपीआई.

क्या करें: अगर जवाब तुरंत मिल जाता है, तो एक या दो सेकंड की देरी करें. इसके उलट, उपयोगकर्ताओं को नतीजे तब ज़्यादा भरोसेमंद लग सकते हैं, जब उन्हें लगता है कि नतीजे जनरेट करने की प्रोसेस, टास्क की कठिनाई के हिसाब से है. ऐनिमेशन का इस्तेमाल करके यह बताएं कि एआई की मदद से कोई प्रोसेस पूरी हुई है.

यह न करें: यूज़र इंटरफ़ेस (यूआई) को अचानक बदलकर उपयोगकर्ताओं को हैरान न करें.

इससे उपयोगकर्ता, एआई की मदद से किए गए बदलावों को तुरंत नेविगेट कर सकते हैं और उन्हें पहले जैसा कर सकते हैं

इन पर लागू होता है: सभी एपीआई.

क्या करें: अपने यूज़र इंटरफ़ेस (यूआई) में स्टेपर या नेविगेशन इतिहास की सुविधा जोड़ें. इससे उपयोगकर्ता, अलग-अलग नतीजे भरोसे के साथ एक्सप्लोर कर पाएंगे. साथ ही, एआई की मदद से किए गए बदलावों को तुरंत पहले जैसा कर पाएंगे. इससे यह पक्का होता है कि अलग-अलग वर्शन अब भी आसानी से उपलब्ध हैं.

यह न करें: उपयोगकर्ता के पिछले ड्राफ़्ट या एआई से मिले ऐसे नतीजे को ओवरराइट न करें जो उसे पसंद आया हो. ऐसा करने पर, उपयोगकर्ता के पास पिछले वर्शन पर वापस जाने, उसे पहले जैसा करने या वर्शन की तुलना करने का विकल्प नहीं होता.

उपयोगकर्ता को कंट्रोल और बदलाव करने की सुविधा देना

इन पर लागू होता है: सभी एपीआई.

क्या करें: जनरेट किए गए सभी कॉन्टेंट में बदलाव करने का आखिरी अधिकार उपयोगकर्ता को दें. उपयोगकर्ता को ओवरराइड करने की आसान सुविधा दें, ताकि फ़ाइनल आउटपुट पर उसका पूरा कंट्रोल बना रहे. एपीआई से गलत नतीजे मिल सकते हैं.

क्या न करें: एआई से जनरेट किए गए नतीजे को एकमात्र विकल्प के तौर पर न दिखाएं.

बार-बार होने वाले काम के लिए, नतीजों को कैश मेमोरी में सेव करना

इन पर लागू होता है: सभी एपीआई.

यह करें: बार-बार इस्तेमाल किए जाने वाले इनपुट या क्वेरी के लिए, लोकल रिज़ल्ट कैश मेमोरी लागू करें. उदाहरण के लिए, sessionStorage या IndexedDB का इस्तेमाल करके. इनपुट को सामान्य बनाएं. इसके लिए, खाली जगह को ट्रिम करें और लोअरकेस का इस्तेमाल करें, ताकि कैश मेमोरी में ज़्यादा डेटा सेव हो सके. इमेज जैसे बड़े इनपुट के लिए, हैश जनरेट करें, ताकि उसे कैश मेमोरी की कुंजी के तौर पर इस्तेमाल किया जा सके. अपनी कैश मेमोरी के लिए, कम से कम टाइम टू लिव (टीटीएल) सेट करें या बैकग्राउंड में अपडेट करते समय, कैश मेमोरी में सेव किए गए नतीजे दिखाएं. अगर नतीजा संतोषजनक नहीं है, तो उपयोगकर्ता को नया अनुमान ट्रिगर करने दें.

क्या न करें: बार-बार की जाने वाली सर्च क्वेरी या एक जैसे डेटा इनपुट के लिए, एक ही अनुमान को फिर से न चलाएं. ऐसा तब करें, जब अलग-अलग नतीजे दिखाने की ज़रूरत न हो. उदाहरण के लिए, जब कोई उपयोगकर्ता खोज के नतीजों के बीच आगे-पीछे नेविगेट करता है. इससे, रिस्पॉन्सिवनेस और लोकल कंप्यूट का बेहतर इस्तेमाल होता है.

6. फ़ॉलबैक रणनीतियां

इस्तेमाल करने से पहले, देखें कि LanguageModel ऑब्जेक्ट, ग्लोबल स्कोप में उपलब्ध है या नहीं:

if ('LanguageModel' in self) {
  // The Prompt API is supported.
} else {
  // Execute fallback strategy
}

अगर Prompt API काम नहीं करता है या उपलब्धता की जांच करने पर 'उपलब्ध नहीं है' दिखता है, तो आपको सही तरीके से फ़ॉलबैक करना होगा:

• रिमोट एपीआई फ़ॉलबैक: पहचान करने के अनुरोध को किसी सर्वर एंडपॉइंट या क्लाउड एपीआई (जैसे, Vertex AI Gemini API) पर रीडायरेक्ट करें.
• लोकल एपीआई फ़ॉलबैक: भाषा की पहचान करने के अनुरोध को किसी लोकल एंडपॉइंट पर रीडायरेक्ट करें. उदाहरण के लिए, Transformers.js का इस्तेमाल करके.