Prompt API

Thomas Steiner

Alexandra Klepper

पब्लिश होने की तारीख: 20 मई, 2025, पिछली बार अपडेट किए जाने की तारीख: 26 अगस्त, 2026

ज़्यादा जानकारी देने वाला वीडियो	वेब	एक्सटेंशन	Chrome स्टेटस	मकसद
GitHub	Chrome 148	Chrome 138	देखें	शिप करने का इरादा
GitHub	पैरामीटर के सैंपल के लिए ऑरिजिन ट्रायल	Chrome 148	देखें	एक्सपेरिमेंट करने का इरादा

Prompt API की मदद से, Chrome में मौजूद फ़ाउंडेशन मॉडल को नैचुरल लैंग्वेज में अनुरोध भेजे जा सकते हैं.

Prompt API का इस्तेमाल कई तरह से किया जा सकता है. उदाहरण के लिए, ये चीज़ें बनाई जा सकती हैं:

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

ये सिर्फ़ कुछ उदाहरण हैं. हमें यह देखने में खुशी होगी कि आपने क्या बनाया है.

Prompt API का इस्तेमाल करना

Prompt API, Chrome में Gemini Nano मॉडल का इस्तेमाल करता है. एपीआई, Chrome में पहले से मौजूद होता है. हालांकि, जब कोई ऑरिजिन पहली बार एपीआई का इस्तेमाल करता है, तो मॉडल अलग से डाउनलोड होता है.

यह जानने के लिए कि मॉडल इस्तेमाल के लिए तैयार है या नहीं, कॉल करें LanguageModel.availability().

const availability = await LanguageModel.availability({
  // The same options in `prompt()` or `promptStreaming()`
});

लैंग्वेज मॉडल को डाउनलोड करने और इंस्टैंशिएट करने के लिए, उपयोगकर्ता के ऐक्टिवेशन की जांच करें. इसके बाद, create() फ़ंक्शन को कॉल करें.

const session = await LanguageModel.create({
  monitor(m) {
    m.addEventListener('downloadprogress', (e) => {
      console.log(`Downloaded ${e.loaded * 100}%`);
    });
  },
});

अगर availability() का जवाब downloading है, तो डाउनलोड की प्रोग्रेस पर नज़र रखें और उपयोगकर्ता को इसकी जानकारी दें, क्योंकि डाउनलोड होने में समय लग सकता है.

सेशन बनाना

Prompt API के चलने के बाद, create() फ़ंक्शन की मदद से सेशन बनाया जा सकता है.

const session = await LanguageModel.create();

create() फ़ंक्शन के ज़रूरी नहीं वाले विकल्पों के ऑब्जेक्ट में, signal फ़ील्ड होता है. इसकी मदद से, सेशन को खत्म करने के लिए AbortSignal पास किया जा सकता है.

const controller = new AbortController();
stopButton.onclick = () => controller.abort();

const session = await LanguageModel.create({
  signal: controller.signal,
});

पैरामीटर के सैंपल

{: #sampling_parameters }

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

• वेब (डिफ़ॉल्ट): डिफ़ॉल्ट रूप से, वेब पर Prompt API, पैरामीटर के सैंपल को नहीं दिखाता. ऐसा इसलिए, क्योंकि temperature और topK जैसी संख्या वाली सेटिंग, अलग-अलग फ़ाउंडेशन मॉडल और आर्किटेक्चर में एक जैसी नहीं होतीं.
• वेब (ऑरिजिन ट्रायल): ऑरिजिन ट्रायल से samplingMode विकल्प अनलॉक हो जाता है. यह आउटपुट की अनुमानित वैल्यू को अडजस्ट करने के लिए, रॉ नंबर के बजाय enum वैल्यू का इस्तेमाल करता है.
• Chrome एक्सटेंशन: पैरामीटर के पुराने सैंपल (topK, temperature) और LanguageModel.params() तरीके को सपोर्ट किया जाता है.

वेब सैंपलिंग मोड (ऑरिजिन ट्रायल)

पैरामीटर के सैंपल के ऑरिजिन ट्रायल में हिस्सा लेते समय, samplingMode विकल्प को LanguageModel.create() (या LanguageModel.availability()) को पास किया जा सकता है.

samplingMode enum की ये वैल्यू इस्तेमाल की जा सकती हैं:

• "most-predictable": सबसे ज़्यादा डिटरमिनिज़्म और अनुमानित वैल्यू.
• "predictable": कम से कम बदलाव के साथ, ज़्यादा अनुमानित आउटपुट.
• "slightly-predictable": थोड़ा अनुमानित आउटपुट.
• "balanced": अनुमानित वैल्यू और क्रिएटिविटी के बीच सही तालमेल (डिफ़ॉल्ट व्यवहार).
• "slightly-creative": थोड़ा अलग और क्रिएटिव आउटपुट.
• "creative": क्रिएटिव और अलग-अलग आउटपुट.
• "most-creative": सबसे ज़्यादा बदलाव और क्रिएटिविटी.

// Available on the web with the Sampling Parameters Origin Trial enabled
const session = await LanguageModel.create({
  samplingMode: 'creative',
});

// The configured sampling mode is exposed on the session instance
console.log(session.samplingMode);
// "creative"

Chrome एक्सटेंशन के लिए, पैरामीटर के सैंपल

Chrome एक्सटेंशन में Prompt API का इस्तेमाल करते समय, हर सेशन को अब भी विकल्पों के ऑब्जेक्ट का इस्तेमाल करके, topK और temperature के हिसाब से पसंद के मुताबिक बनाया जा सकता है.

स्टैटिक LanguageModel.params() फ़ंक्शन, आपको भाषा मॉडल की डिफ़ॉल्ट और ज़्यादा से ज़्यादा पैरामीटर की सीमाओं के बारे में बताता है:

• defaultTopK: डिफ़ॉल्ट टॉप-के वैल्यू.
• maxTopK: ज़्यादा से ज़्यादा टॉप-के वैल्यू.
• defaultTemperature: डिफ़ॉल्ट तापमान.
• maxTemperature: ज़्यादा से ज़्यादा तापमान.

// Only available in Chrome Extensions
const params = await LanguageModel.params();
// {defaultTopK: 3, maxTopK: 128, defaultTemperature: 1, maxTemperature: 2}

// Initializing a new session in extensions must either specify both `topK` and
// `temperature` or neither of them.
const slightlyHighTemperatureSession = await LanguageModel.create({
  temperature: Math.min(params.defaultTemperature * 1.2, params.maxTemperature),
  topK: params.defaultTopK,
});

console.log(slightlyHighTemperatureSession.temperature);
console.log(slightlyHighTemperatureSession.topK);

शुरुआती प्रॉम्प्ट के साथ कॉन्टेक्स्ट जोड़ना

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

const session = await LanguageModel.create({
  initialPrompts: [
    { role: 'system', content: 'You are a helpful and friendly assistant.' },
    { role: 'user', content: 'What is the capital of Italy?' },
    { role: 'assistant', content: 'The capital of Italy is Rome.' },
    { role: 'user', content: 'What language is spoken there?' },
    {
      role: 'assistant',
      content: 'The official language of Italy is Italian. [...]',
    },
  ],
});

प्रीफ़िक्स की मदद से जवाबों को सीमित करना

मॉडल के पिछले जवाबों के बारे में ज़्यादा जानकारी देने के लिए, पिछली भूमिकाओं के अलावा "assistant" की भूमिका जोड़ी जा सकती है. उदाहरण के लिए:

const followup = await session.prompt([
  {
    role: "user",
    content: "I'm nervous about my presentation tomorrow"
  },
  {
    role: "assistant",
    content: "Presentations are tough!"
  }
]);

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

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

अनुमानित इनपुट और आउटपुट जोड़ना

Prompt API में मल्टीमॉडल की सुविधाएं हैं और यह कई भाषाओं को सपोर्ट करता है. सेशन बनाते समय, expectedInputs और expectedOutputs के मोड और भाषाएं सेट करें.

• type: अनुमानित मोड.
  • expectedInputs के लिए, यह text, image या audio हो सकता है.
  • expectedOutputs के लिए, Prompt API सिर्फ़ text की अनुमति देता है.
• languages: अनुमानित भाषा या भाषाओं को सेट करने के लिए कलेक्शन. Prompt API "en", "ja", "es", "de" और "fr" को स्वीकार करता है. अन्य भाषाओं के लिए सहायता की सुविधा, फ़िलहाल डेवलपमेंट के दौर में है.
  • expectedInputs के लिए, सिस्टम प्रॉम्प्ट की भाषा और उपयोगकर्ता के प्रॉम्प्ट की एक या उससे ज़्यादा अनुमानित भाषाएं सेट करें.
  • expectedOutputs की एक या उससे ज़्यादा भाषाएं सेट करें.

const session = await LanguageModel.create({
  expectedInputs: [
    { type: "text", languages: ["en" /* system prompt */, "ja" /* user prompt */] }
  ],
  expectedOutputs: [
    { type: "text", languages: ["ja"] }
  ]
});

अगर मॉडल को ऐसा इनपुट या आउटपुट मिलता है जिसे वह सपोर्ट नहीं करता, तो आपको "NotSupportedError" DOMException मिल सकता है.

मल्टीमॉडल की सुविधाएं

इन सुविधाओं की मदद से, ये काम किए जा सकते हैं:

• उपयोगकर्ताओं को चैट ऐप्लिकेशन में भेजे गए ऑडियो मैसेज की ट्रांसक्रिप्ट बनाने की अनुमति देना.
• कैप्शन या वैकल्पिक लेख में इस्तेमाल करने के लिए, अपनी वेबसाइट पर अपलोड की गई किसी इमेज के बारे में जानकारी देना.

ऑडियो इनपुट के साथ Prompt API का इस्तेमाल करने के लिए, Mediarecorder Audio Prompt का डेमो देखें. साथ ही, इमेज इनपुट के साथ Prompt API का इस्तेमाल करने के लिए, Canvas Image Prompt डेमो देखें.

Prompt API, इनपुट के इन टाइप को सपोर्ट करता है:

• ऑडियो:
  • AudioBuffer
  • ArrayBufferView
  • ArrayBuffer
  • Blob
• विज़ुअल:
  • HTMLImageElement
  • SVGImageElement
  • HTMLVideoElement (वीडियो की मौजूदा पोज़िशन पर वीडियो फ़्रेम का इस्तेमाल करता है)
  • HTMLCanvasElement
  • ImageBitmap
  • OffscreenCanvas
  • VideoFrame
  • Blob
  • ImageData

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

const session = await LanguageModel.create({
  expectedInputs: [
    { type: "text", languages: ["en"] },
    { type: "audio" },
    { type: "image" },
  ],
  expectedOutputs: [{ type: "text", languages: ["en"] }],
});

const referenceImage = await (await fetch("reference-image.jpeg")).blob();
const userDrawnImage = document.querySelector("canvas");

const response1 = await session.prompt([
  {
    role: "user",
    content: [
      {
        type: "text",
        value:
          "Give a helpful artistic critique of how well the second image matches the first:",
      },
      { type: "image", value: referenceImage },
      { type: "image", value: userDrawnImage },
    ],
  },
]);
console.log(response1);

const audioBuffer = await captureMicrophoneInput({ seconds: 10 });

const response2 = await session.prompt([
  {
    role: "user",
    content: [
      { type: "text", value: "My response to your critique:" },
      { type: "audio", value: audioBuffer },
    ],
  },
]);
console.log(response2);

मैसेज जोड़ना

खास तौर पर, मल्टीमॉडल इनपुट के साथ प्रॉम्प्ट करने पर, अनुमान लगाने में कुछ समय लग सकता है. सेशन को पॉप्युलेट करने के लिए, पहले से तय किए गए प्रॉम्प्ट भेजना काम का हो सकता है. इससे मॉडल को प्रोसेस करने में मदद मिल सकती है.

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

उदाहरण के लिए:

const session = await LanguageModel.create({
  initialPrompts: [
    {
      role: 'system',
      content:
        'You are a skilled analyst who correlates patterns across multiple images.',
    },
  ],
  expectedInputs: [{ type: 'image' }],
});

fileUpload.onchange = async () => {
  await session.append([
    {
      role: 'user',
      content: [
        {
          type: 'text',
          value: `Here's one image. Notes: ${fileNotesInput.value}`,
        },
        { type: 'image', value: fileUpload.files[0] },
      ],
    },
  ]);
};

analyzeButton.onclick = async (e) => {
  analysisResult.textContent = await session.prompt(userQuestionInput.value);
};

append() से मिलने वाला प्रॉमिस, तब पूरा होता है, जब प्रॉम्प्ट की पुष्टि हो जाती है, उसे प्रोसेस कर लिया जाता है, और सेशन में जोड़ दिया जाता है. अगर प्रॉम्प्ट को जोड़ा नहीं जा सकता, तो प्रॉमिस अस्वीकार कर दिया जाता है.

JSON स्कीमा पास करना

वैल्यू के तौर पर JSON स्कीमा पास करने के लिए, prompt() या promptStreaming() तरीके में responseConstraint फ़ील्ड जोड़ें. इसके बाद, स्ट्रक्चर्ड आउटपुट का इस्तेमाल Prompt API के साथ किया जा सकता है.

यहां दिए गए उदाहरण में, JSON स्कीमा यह पक्का करता है कि मॉडल, यह बताने के लिए true या false के साथ जवाब दे कि दिया गया मैसेज, मिट्टी के बर्तनों के बारे में है या नहीं.

const session = await LanguageModel.create();

const schema = {
  "type": "boolean"
};

const post = "Mugs and ramen bowls, both a bit smaller than intended, but that
happens with reclaim. Glaze crawled the first time around, but pretty happy
with it after refiring.";

const result = await session.prompt(
  `Is this post about pottery?\n\n${post}`,
  {
    responseConstraint: schema,
  }
);
console.log(JSON.parse(result));
// true

आपके लागू करने में, मॉडल को भेजे गए मैसेज के हिस्से के तौर पर, JSON स्कीमा या रेगुलर एक्सप्रेशन शामिल हो सकता है. इससे कॉन्टेक्स्ट विंडो का कुछ हिस्सा इस्तेमाल होता है. session.measureContextUsage() को responseConstraint विकल्प पास करके, यह मेज़र किया जा सकता है कि कॉन्टेक्स्ट विंडो का कितना हिस्सा इस्तेमाल होगा.

omitResponseConstraintInput विकल्प की मदद से, इस व्यवहार से बचा जा सकता है. अगर ऐसा किया जाता है, तो हमारा सुझाव है कि प्रॉम्प्ट में कुछ निर्देश शामिल करें:

const result = await session.prompt(`
  Summarize this feedback into a rating between 0-5. Only output a JSON
  object { rating }, with a single property whose value is a number:
  The food was delicious, service was excellent, will recommend.
`, { responseConstraint: schema, omitResponseConstraintInput: true });

मॉडल को प्रॉम्प्ट करना

prompt() या promptStreaming() फ़ंक्शन की मदद से, मॉडल को प्रॉम्प्ट किया जा सकता है.

अनुरोध के आधार पर आउटपुट

अगर आपको कम शब्दों में जवाब चाहिए, तो prompt() फ़ंक्शन का इस्तेमाल किया जा सकता है. यह जवाब उपलब्ध होने पर उसे दिखाता है.

// Start by checking if it's possible to create a session based on the
// availability of the model, and the characteristics of the device.
const available = await LanguageModel.availability({
  expectedInputs: [{type: 'text', languages: ['en']}],
  expectedOutputs: [{type: 'text', languages: ['en']}],
});

if (available !== 'unavailable') {
  const session = await LanguageModel.create();

  // Prompt the model and wait for the whole result to come back.
  const result = await session.prompt('Write me a poem!');
  console.log(result);
}

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

अगर आपको लंबा जवाब चाहिए, तो promptStreaming() फ़ंक्शन का इस्तेमाल करना चाहिए. इससे मॉडल से जवाब मिलने पर, उसके कुछ हिस्से दिखाए जा सकते हैं. promptStreaming() फ़ंक्शन, ReadableStream दिखाता है.

const available = await LanguageModel.availability({
  expectedInputs: [{type: 'text', languages: ['en']}],
  expectedOutputs: [{type: 'text', languages: ['en']}],
});
if (available !== 'unavailable') {
  const session = await LanguageModel.create();

  // Prompt the model and stream the result:
  const stream = session.promptStreaming('Write me an extra-long poem!');
  for await (const chunk of stream) {
    console.log(chunk);
  }
}

प्रॉम्प्ट करना बंद करना

prompt() और promptStreaming() , दोनों में signal फ़ील्ड के साथ दूसरा पैरामीटर जोड़ा जा सकता है. इसकी मदद से, प्रॉम्प्ट को रन करना बंद किया जा सकता है.

const controller = new AbortController();
stopButton.onclick = () => controller.abort();

const result = await session.prompt('Write me a poem!', {
  signal: controller.signal,
});

सेशन मैनेजमेंट

हर सेशन, बातचीत के कॉन्टेक्स्ट को ट्रैक करता है. सेशन की कॉन्टेक्स्ट विंडो पूरी होने तक, पिछले इंटरैक्शन को ध्यान में रखकर, आगे के इंटरैक्शन किए जाते हैं.

हर सेशन में, प्रोसेस किए जा सकने वाले टोकन की संख्या की एक सीमा होती है. इस सीमा के हिसाब से अपनी प्रोग्रेस की जांच करने के लिए, यह तरीका अपनाएं:

console.log(`${session.contextUsage}/${session.contextWindow}`);

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

सेशन पर contextoverflow इवेंट को सुनकर, ऐसे ओवरफ़्लो का पता लगाया जा सकता है:

session.addEventListener("contextoverflow", () => {
  console.log("We've gone past the context window, and some inputs will be dropped!");
});

अगर नए प्रॉम्प्ट को प्रोसेस करने के लिए, बातचीत के इतिहास से ज़रूरत के मुताबिक टोकन नहीं हटाए जा सकते, तो prompt() या promptStreaming() कॉल, QuotaExceededError अपवाद के साथ फ़ेल हो जाएगा. साथ ही, कुछ भी नहीं हटाया जाएगा. QuotaExceededError में ये प्रॉपर्टी होती हैं:

• requested: इनपुट में कितने टोकन हैं
• contextWindow: कितने टोकन उपलब्ध थे

सेशन मैनेजमेंट के बारे में ज़्यादा जानें.

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

संसाधनों को सुरक्षित रखने के लिए, clone() फ़ंक्शन की मदद से, मौजूदा सेशन को कॉपी किया जा सकता है. इससे बातचीत की एक फ़ोर्क कॉपी बनती है. इसमें कॉन्टेक्स्ट और शुरुआती प्रॉम्प्ट सुरक्षित रहते हैं.

clone() फ़ंक्शन में, signal फ़ील्ड के साथ ज़रूरी नहीं वाला विकल्पों का ऑब्जेक्ट जोड़ा जा सकता है. इसकी मदद से, क्लोन किए गए सेशन को खत्म करने के लिए AbortSignal पास किया जा सकता है.

const controller = new AbortController();
stopButton.onclick = () => controller.abort();

const clonedSession = await session.clone({
  signal: controller.signal,
});

सेशन खत्म करना

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

await session.prompt(
  "You are a friendly, helpful assistant specialized in clothing choices."
);

session.destroy();

// The promise is rejected with an error explaining that
// the session is destroyed.
await session.prompt(
  "What should I wear today? It is sunny, and I am choosing between a t-shirt
  and a polo."
);

डेमो

हमने Prompt API के कई उदाहरणों को एक्सप्लोर करने के लिए, कई डेमो बनाए हैं. ये डेमो, वेब ऐप्लिकेशन हैं:

• Prompt API प्लेग्राउंड
• Mediarecorder Audio Prompt
• Canvas Image Prompt

Chrome एक्सटेंशन में Prompt API की जांच करने के लिए, डेमो एक्सटेंशन इंस्टॉल करें. एक्सटेंशन का सोर्स कोड, GitHub पर उपलब्ध है.

परफ़ॉर्मेंस की रणनीति

वेब के लिए Prompt API, फ़िलहाल डेवलपमेंट के दौर में है. जब तक हम इस एपीआई को तैयार नहीं कर लेते, बेहतर परफ़ॉर्मेंस के लिए, सेशन मैनेजमेंट के सबसे सही तरीके देखें.

अनुमति से जुड़ी नीति, iframe, और वेब वर्कर

डिफ़ॉल्ट रूप से, Prompt API सिर्फ़ टॉप-लेवल विंडो और उनके सेम-ऑरिजिन iframe के लिए उपलब्ध होता है. अनुमति से जुड़ी नीति के allow="" एट्रिब्यूट का इस्तेमाल करके, क्रॉस-ऑरिजिन iframe को एपीआई का ऐक्सेस दिया जा सकता है:

<!--
  The hosting site at https://main.example.com can grant a cross-origin iframe
  at https://cross-origin.example.com/ access to the Prompt API by
  setting the `allow="language-model"` attribute.
-->
<iframe src="https://cross-origin.example.com/" allow="language-model"></iframe>

फ़िलहाल, Prompt API, वेब वर्कर में उपलब्ध नहीं है. ऐसा इसलिए, क्योंकि अनुमति से जुड़ी नीति के स्टेटस की जांच करने के लिए, हर वर्कर के लिए ज़िम्मेदार दस्तावेज़ बनाना मुश्किल है.

हिस्सा लें और सुझाव/राय दें या शिकायत करें

आपके सुझाव और राय से, इस एपीआई और पहले से मौजूद सभी एआई एपीआई के आने वाले वर्शन को बनाने और लागू करने के तरीके पर सीधा असर पड़ सकता है.

• Chrome के लागू करने के तरीके के बारे में सुझाव/राय देने या शिकायत करने के लिए, गड़बड़ी की रिपोर्ट या सुविधा का अनुरोध सबमिट करें.
• मौजूदा समस्या पर टिप्पणी करके या Prompt API GitHub रिपॉज़िटरी में नई समस्या खोलकर, एपीआई के आकार के बारे में सुझाव/राय दें या शिकायत करें.
• सार्वजनिक तौर पर उपलब्ध होने से पहले वाला वर्शन के प्रोग्राम में शामिल हों.