De Prompt-API

Thomas Steiner

Alexandra Klepper

Gepubliceerd: 20 mei 2025, Laatst bijgewerkt: 21 september 2025

Uitleg	Web	Uitbreidingen	Chrome-status	Intentie
GitHub	Oorsprongsproef	Chrome 138	Weergave	Voornemen om te experimenteren

Met de Prompt API kunt u in de browser verzoeken in natuurlijke taal naar Gemini Nano sturen.

Er zijn veel manieren waarop je de Prompt API kunt gebruiken. Je zou bijvoorbeeld het volgende kunnen bouwen:

• Zoeken met behulp van AI : beantwoord vragen op basis van de inhoud van een webpagina.
• Gepersonaliseerde nieuwsfeeds : Bouw een feed die artikelen dynamisch indeelt in categorieën en gebruikers de mogelijkheid biedt om op basis daarvan te filteren.
• Aangepaste contentfilters . Analyseer nieuwsartikelen en vervaag of verberg automatisch content op basis van door de gebruiker gedefinieerde onderwerpen.
• Agenda-afspraken aanmaken . Ontwikkel een Chrome-extensie die automatisch details van evenementen van webpagina's extraheert, zodat gebruikers in slechts enkele stappen agenda-items kunnen aanmaken.
• Seamless contact extraction . Build an extension that extracts contact information from websites, making it easier for users to contact a business or add details to their list of contacts.

Dit zijn slechts een paar mogelijkheden, en we zijn benieuwd wat jullie gaan creëren.

Gebruik de Prompt API

De Prompt API maakt gebruik van het Gemini Nano-model in Chrome. Hoewel de API is ingebouwd in Chrome, wordt het model apart gedownload de eerste keer dat een applicatie de API gebruikt. Voordat u deze API gebruikt, dient u het beleid van Google inzake verboden gebruik van generatieve AI te raadplegen.

Om te bepalen of het model klaar is voor gebruik, roept u LanguageModel.availability() aan.

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

Om de download te starten en het taalmodel te initialiseren, controleer je of de gebruiker is geactiveerd . Roep vervolgens de functie create() aan.

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

If the response to availability() was downloading , listen for download progress and inform the user , as the download may take time.

Gebruik op localhost

Alle ingebouwde AI-API's zijn beschikbaar op localhost in Chrome. Stel de volgende vlaggen in op 'Ingeschakeld' :

• chrome://flags/#optimization-guide-on-device-model
• chrome://flags/#prompt-api-for-gemini-nano-multimodal-input

Klik vervolgens op Opnieuw starten of herstart Chrome. Als je fouten tegenkomt, los dan de problemen met localhost op .

Modelparameters

De functie params() geeft je informatie over de parameters van het taalmodel. Het object heeft de volgende velden:

• defaultTopK : De standaard top-K waarde.
• maxTopK : The maximum top-K value.
• defaultTemperature : De standaardtemperatuur .
• maxTemperature : De maximale temperatuur.

// Only available when using the Prompt API for Chrome Extensions.
await LanguageModel.params();
// {defaultTopK: 3, maxTopK: 128, defaultTemperature: 1, maxTemperature: 2}

Een sessie aanmaken

Zodra de Prompt API kan worden uitgevoerd, maak je een sessie aan met de functie create() .

const session = await LanguageModel.create();

Maak een sessie aan met de Prompt API voor Chrome-extensies.

Wanneer je de Prompt API voor Chrome-extensies gebruikt, kan elke sessie worden aangepast met topK en temperature via een optioneel optieobject. De standaardwaarden voor deze parameters worden geretourneerd door LanguageModel.params() .

// Only available when using the Prompt API for Chrome Extensions.
const params = await LanguageModel.params();
// Initializing a new session must either specify both `topK` and
// `temperature` or neither of them.
// Only available when using the Prompt API for Chrome Extensions.
const slightlyHighTemperatureSession = await LanguageModel.create({
  temperature: Math.max(params.defaultTemperature * 1.2, 2.0),
  topK: params.defaultTopK,
});

Het optionele opties-object van de create() functie accepteert ook een signal , waarmee je een AbortSignal kunt doorgeven om de sessie te beëindigen.

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

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

Voeg context toe met behulp van de eerste aanwijzingen.

With initial prompts, you can provide the language model with context about previous interactions, for example, to allow the user to resume a stored session after a browser restart.

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. [...]',
    },
  ],
});

Beperk reacties met een voorvoegsel

Je kunt, naast de reeds bestaande rollen, een "assistant" rol toevoegen om de eerdere reacties van het model verder uit te werken. Bijvoorbeeld:

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

In sommige gevallen wilt u, in plaats van een nieuw antwoord aan te vragen, mogelijk een deel van het antwoordbericht voor de rol "assistant" vooraf invullen. Dit kan handig zijn om het taalmodel te sturen naar een specifiek antwoordformaat. Voeg hiervoor prefix: true toe aan het laatste antwoordbericht voor de rol "assistant" . Bijvoorbeeld:

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

Voeg de verwachte invoer en uitvoer toe.

De Prompt API beschikt over multimodale mogelijkheden en ondersteunt meerdere talen. Stel de expectedInputs en expectedOutputs en talen in bij het aanmaken van uw sessie.

• type : Verwachte modaliteit.
  • Voor expectedInputs kan dit text , image of audio zijn.
  • Voor expectedOutputs staat de Prompt API alleen text toe.
• languages : Een array om de verwachte taal of talen in te stellen. De Prompt API accepteert "en" , "ja" en "es" . Ondersteuning voor extra talen is in ontwikkeling.
  • Stel voor expectedInputs de systeemprompttaal en een of meer verwachte gebruikersprompttalen in.
  • Stel een of meer expectedOutputs uitvoertalen in.

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

U kunt een DOMException met de foutmelding "NotSupportedError" ontvangen als het model een niet-ondersteunde invoer of uitvoer tegenkomt.

Multimodale mogelijkheden

Met deze mogelijkheden zou u:

• Gebruikers de mogelijkheid bieden om audioberichten die via een chatapplicatie worden verzonden, te transcriberen.
• Beschrijf een afbeelding die naar uw website is geüpload voor gebruik in een onderschrift of alternatieve tekst.

Bekijk de Mediarecorder Audio Prompt- demo voor het gebruik van de Prompt API met audio-invoer en de Canvas Image Prompt- demo voor het gebruik van de Prompt API met afbeeldingsinvoer.

De Prompt API ondersteunt de volgende invoertypen:

• Audio:
  • AudioBuffer
  • ArrayBufferView
  • ArrayBuffer
  • Blob
• Visueel:
  • HTMLImageElement
  • SVGImageElement
  • HTMLVideoElement (gebruikt het videobeeld op de huidige videopositie)
  • HTMLCanvasElement
  • ImageBitmap
  • OffscreenCanvas
  • VideoFrame
  • Blob
  • ImageData

This snippet shows a multimodal session that first processes two visuals (one image Blob and one HTMLCanvasElement ) and has the AI compare them, and that second lets the user respond with an audio recording (as an 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);

Berichten toevoegen

Inferentie kan enige tijd in beslag nemen, vooral bij het gebruik van meerdere soorten input. Het kan nuttig zijn om vooraf vooraf bepaalde prompts te versturen om de sessie te vullen, zodat het model een voorsprong krijgt bij de verwerking.

Hoewel initialPrompts nuttig zijn bij het aanmaken van een sessie, kan de append() methode, in combinatie met de prompt() of promptStreaming() methoden, worden gebruikt om extra contextuele prompts weer te geven nadat de sessie is aangemaakt.

Bijvoorbeeld:

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);
};

De belofte die door append() wordt geretourneerd, wordt vervuld zodra de prompt is gevalideerd, verwerkt en aan de sessie is toegevoegd. De belofte wordt afgewezen als de prompt niet kan worden toegevoegd.

Geef een JSON-schema door.

Voeg het veld responseConstraint toe aan prompt() of promptStreaming() methode om een ​​JSON-schema als waarde door te geven. Je kunt vervolgens gestructureerde uitvoer gebruiken met de Prompt API.

In het volgende voorbeeld zorgt het JSON-schema ervoor dat het model met true of false reageert om te classificeren of een bepaald bericht over aardewerk gaat.

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

Je implementatie kan een JSON-schema of reguliere expressie bevatten als onderdeel van het bericht dat naar het model wordt verzonden. Dit gebruikt een deel van het contextvenster . Je kunt meten hoeveel van het contextvenster dit gebruikt door de optie responseConstraint door te geven aan session.measureContextUsage() .

U kunt dit gedrag voorkomen met de optie omitResponseConstraintInput . Als u dit doet, raden we u aan om in de prompt een toelichting op te nemen:

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 });

Geef het model een aanwijzing.

Je kunt het model aansturen met de functies prompt() of promptStreaming() .

Op verzoek gebaseerde uitvoer

Als je een snel resultaat verwacht, kun je de prompt() functie gebruiken die het antwoord teruggeeft zodra het beschikbaar is.

// 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);
}

Gestreamde uitvoer

Als u een langere reactie verwacht, kunt u de promptStreaming() functie gebruiken. Hiermee kunt u gedeeltelijke resultaten weergeven zodra deze van het model binnenkomen. De promptStreaming() functie retourneert een 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);
  }
}

Stop met aansporen

Zowel prompt() als promptStreaming() accepteren een optionele tweede parameter met een signal , waarmee je de lopende prompts kunt stoppen.

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

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

Sessiebeheer

Elke sessie houdt de context van het gesprek bij. Eerdere interacties worden meegenomen in toekomstige interacties totdat het contextvenster van de sessie vol is.

Elke sessie heeft een maximum aantal tokens dat verwerkt kan worden. Controleer uw voortgang richting deze limiet met de volgende informatie:

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

Het is mogelijk om een ​​prompt te versturen die ervoor zorgt dat het contextvenster overloopt. In dergelijke gevallen worden de eerste delen van het gesprek met het taalmodel verwijderd, één prompt- en antwoordpaar tegelijk, totdat er voldoende tokens beschikbaar zijn om de nieuwe prompt te verwerken. De systeemprompt vormt hierop een uitzondering; deze wordt nooit verwijderd.

Dergelijke overloopfouten kunnen worden gedetecteerd door te luisteren naar de contextoverflow -gebeurtenis op de sessie:

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

Als het niet mogelijk is om voldoende tokens uit de gespreksgeschiedenis te verwijderen om de nieuwe prompt te verwerken, zal de aanroep prompt() of promptStreaming() mislukken met een QuotaExceededError uitzondering en zal er niets worden verwijderd. De QuotaExceededError heeft de volgende eigenschappen:

• requested : uit hoeveel tokens de invoer bestaat.
• contextWindow : hoeveel tokens waren er beschikbaar?

Leer meer over sessiebeheer .

Een sessie klonen

Om resources te behouden, kunt u een bestaande sessie kopiëren met de functie clone() . Hiermee wordt een fork van het gesprek gemaakt, waarbij de context en de initiële prompt behouden blijven.

De functie clone() accepteert een optioneel optieobject met een signal , waarmee je een AbortSignal kunt doorgeven om de gekloonde sessie te beëindigen.

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

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

Een sessie beëindigen

Roep destroy() aan om resources vrij te geven als je een sessie niet langer nodig hebt. Wanneer een sessie wordt vernietigd, kan deze niet langer worden gebruikt en wordt alle lopende uitvoering afgebroken. Je wilt de sessie mogelijk behouden als je van plan bent het model regelmatig te gebruiken, aangezien het aanmaken van een sessie enige tijd kan duren.

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."
);

Demo's

We hebben verschillende demo's ontwikkeld om de vele toepassingsmogelijkheden van de Prompt API te verkennen. De volgende demo's zijn webapplicaties:

• Prompt API-speeltuin
• Audioprompt voor Mediarecorder
• Canvas Afbeelding prompt

Om de Prompt API in Chrome-extensies te testen, installeer je de demo-extensie. De broncode van de extensie is beschikbaar op GitHub.

Prestatiestrategie

De Prompt API voor het web is nog in ontwikkeling. Raadpleeg in de tussentijd onze best practices voor sessiebeheer voor optimale prestaties.

Toestemmingsbeleid, iframes en webworkers

Standaard is de Prompt API alleen beschikbaar voor vensters op het hoogste niveau en hun iframes van dezelfde oorsprong. Toegang tot de API kan worden gedelegeerd aan iframes van een andere oorsprong met behulp van het attribuut allow="" in het machtigingsbeleid.

<!--
  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>

De Prompt API is momenteel niet beschikbaar in Web Workers, vanwege de complexiteit van het opstellen van een verantwoordelijk document voor elke worker om de status van het machtigingsbeleid te controleren.

Doe mee en deel je feedback.

Uw input kan direct van invloed zijn op hoe we toekomstige versies van deze API en alle ingebouwde AI-API's ontwikkelen en implementeren.

• Voor feedback over de implementatie in Chrome kunt u een bugrapport of een functieverzoek indienen.
• Geef uw feedback over de API-structuur door te reageren op een bestaand probleem of door een nieuw probleem aan te maken in de Prompt API GitHub-repository .
• Neem deel aan het programma voor vroege preview .