De Prompt API

Thomas Steiner
Alexandra Klepper
Alexandra Klepper
GitHub Bluesky

Gepubliceerd: 20 mei 2025, Laatst geüpdatet: 21 oktober 2026

Uitlegvideo Web Extensies Chrome-status Intentie
GitHub Chrome 148 Chrome 138 Bekijken Intent to Ship
GitHub Origin-test Origin trial voor steekproefparameters Chrome 148 Bekijken Intent to Experiment

Met de Prompt API kun je verzoeken in natuurlijke taal sturen naar het funderingsmodel in Chrome.

Je kunt de Prompt API op veel manieren gebruiken. Je kunt bijvoorbeeld het volgende maken:

  • AI-gestuurd zoeken: Beantwoord vragen op basis van de content van een webpagina.
  • Gepersonaliseerde nieuwsfeeds: Maak een feed die artikelen dynamisch classificeert met categorieën en gebruikers de mogelijkheid biedt om op die content te filteren.
  • Aangepaste contentfilters. Nieuwsartikelen analyseren en content automatisch vervagen of verbergen op basis van door de gebruiker gedefinieerde onderwerpen.
  • Agenda-afspraken maken. Ontwikkel een Chrome-extensie die automatisch afspraakgegevens uit webpagina's haalt, zodat gebruikers in een paar stappen agenda-items kunnen maken.
  • Naadloze contactextractie. Maak een extensie die contactgegevens van websites haalt, zodat gebruikers makkelijker contact kunnen opnemen met een bedrijf of gegevens kunnen toevoegen aan hun lijst met contacten.

Dit zijn maar een paar mogelijkheden en we zijn benieuwd wat je gaat maken.

De hardwarevereisten controleren

De volgende vereisten gelden voor ontwikkelaars en gebruikers die functies gebruiken via deze API's in Chrome. Andere browsers kunnen andere vereisten hebben.

De Language Detector API en Translator API werken in Chrome op desktops. Deze API's werken niet op mobiele apparaten.

De Prompt API, Summarizer API, Writer API, Rewriter API en Proofreader API werken in Chrome als aan de volgende voorwaarden wordt voldaan:

  • Besturingssysteem: Windows 10 of 11, macOS 13+ (Ventura en hoger), Linux of ChromeOS (vanaf Platform 16389.0.0) op Chromebook Plus-apparaten. Chrome voor Android, iOS en ChromeOS op niet-Chromebook Plus-apparaten worden nog niet ondersteund door de API's die basismodellen gebruiken.
  • Opslag: Minstens 22 GB vrije ruimte op het volume dat je Chrome-profiel bevat.
  • GPU of CPU: Ingebouwde modellen kunnen worden uitgevoerd met GPU of CPU.
    • GPU: Strikt meer dan 4 GB VRAM.
    • CPU: 16 GB RAM of meer en 4 CPU-kernen of meer.
    • Opmerking: Voor de Prompt API met audio-invoer is een GPU vereist.
  • Netwerk: Onbeperkte data of een verbinding zonder datalimiet.

De exacte grootte van Gemini Nano kan variëren als de browser het model updatet. Ga naar chrome://on-device-internals om de huidige grootte te bepalen.

De Prompt API gebruiken

De Prompt API gebruikt het Gemini Nano-model in Chrome. De API is ingebouwd in Chrome, maar het model wordt afzonderlijk gedownload als een oorsprong de API voor het eerst gebruikt.

Roep LanguageModel.availability() aan om te bepalen of het model klaar is voor gebruik.

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

Controleer op gebruikersactivering om de download te activeren en het taalmodel te instantiëren. Roep daarna de functie create() aan.

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

Als de reactie op availability() downloading was, luister je naar de downloadvoortgang en informeer je de gebruiker, omdat de download even kan duren.

Een sessie maken

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

const session = await LanguageModel.create();

Het optionele object met opties van de functie create() heeft een veld 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,
});

Steekproefparameters

Door de steekproef te beheren, kun je afstemmen hoe voorspelbaar (deterministisch) of creatief (gevarieerd) de reacties van het model zijn. De beschikbaarheid van steekproefparameters verschilt tussen het webplatform en Chrome-extensies:

  • Web: Gebruik de optie samplingMode, die beschrijvende enum-waarden gebruikt in plaats van onbewerkte getallen om de voorspelbaarheid van de uitvoer aan te passen.
  • Chrome-extensies: Verouderde numerieke parameters (topK, temperature) en de methode LanguageModel.params() worden ondersteund.

Modus voor websampling

Geef de optie samplingMode door aan LanguageModel.create() (of LanguageModel.availability()).

De ondersteunde enum-waarden voor samplingMode zijn:

  • "most-predictable": Hoogste determinisme en voorspelbaarheid.
  • "predictable": Voorspelbaardere uitvoer met minimale variatie.
  • "slightly-predictable": Enigszins voorspelbare uitvoer.
  • "balanced": Een balans tussen voorspelbaarheid en creativiteit (typisch standaardgedrag).
  • "slightly-creative": Enigszins gevarieerde en creatieve uitvoer.
  • "creative": Creatieve en gevarieerde uitvoer.
  • "most-creative": Maximale variabiliteit en creativiteit.
// 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"

Steekproefparameters voor Chrome-extensies

Als je de Prompt API in Chrome-extensies gebruikt, kun je elke sessie nog steeds aanpassen met topK en temperature via het optieobject.

De statische functie LanguageModel.params() geeft je informatie over de standaard- en maximale parameterlimieten van het taalmodel:

  • defaultTopK: De standaardwaarde voor top-K.
  • maxTopK: De maximale top-K- waarde.
  • defaultTemperature: De standaard temperatuur.
  • maxTemperature: De maximumtemperatuur.
// 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);

Context toevoegen met eerste prompts

Met initiële prompts kun je het taalmodel context geven over eerdere interacties, bijvoorbeeld om de gebruiker een opgeslagen sessie te laten hervatten nadat de browser opnieuw is opgestart.

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

Reacties beperken met een voorvoegsel

Je kunt een "assistant"-rol toevoegen, naast eerdere rollen, om de eerdere reacties van het model uit te breiden. Voorbeeld:

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

In sommige gevallen wil je misschien niet om een nieuwe reactie vragen, maar een deel van het reactiebericht van de "assistant"-rol vooraf invullen. Dit kan handig zijn om het taalmodel te sturen naar een specifieke reactie-indeling. Voeg hiervoor prefix: true toe aan het laatste bericht met de rol "assistant". Voorbeeld:

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

Verwachte invoer en uitvoer toevoegen

De Prompt API heeft multimodale mogelijkheden en ondersteunt meerdere talen. Stel de modaliteiten en talen voor expectedInputs en expectedOutputs in wanneer je je sessie maakt.

  • type: Modaliteit verwacht.
    • Voor expectedInputs kan dit text, image of audio zijn.
    • Voor expectedOutputs staat de Prompt API alleen text toe.
  • languages: Matrix om de verwachte taal of talen in te stellen. De Prompt API accepteert "en", "ja", "es", "de" en "fr". We werken aan ondersteuning voor meer talen.
    • Stel voor expectedInputs de taal van de systeemprompt en een of meer verwachte talen voor de gebruikersprompt in.
    • Stel een of meer expectedOutputs-talen in.
const session = await LanguageModel.create({
  expectedInputs: [
    { type: "text", languages: ["en" /* system prompt */, "ja" /* user prompt */] }
  ],
  expectedOutputs: [
    { type: "text", languages: ["ja"] }
  ]
});

Je kunt een "NotSupportedError" DOMException krijgen als het model een niet-ondersteunde invoer of uitvoer tegenkomt.

Multimodale mogelijkheden

Met deze mogelijkheden kun je het volgende doen:

  • Gebruikers toestaan transcripties te maken van audioberichten die zijn gestuurd in een chat-app.
  • Beschrijf een afbeelding die naar je website is geüpload voor gebruik in een bijschrift of alt-tekst.

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

De Prompt API ondersteunt de volgende invoertypen:

Dit fragment toont een multimodale sessie die eerst 2 visuele elementen verwerkt (één afbeelding Blob en één HTMLCanvasElement) en de AI deze laat vergelijken. Daarna laat de sessie de gebruiker reageren met een audio-opname (als een 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 even duren, vooral als je prompts met multimodale invoer gebruikt. Het kan nuttig zijn om vooraf bepaalde prompts te sturen om de sessie te vullen, zodat het model een voorsprong heeft bij de verwerking.

Hoewel initialPrompts nuttig zijn bij het maken van sessies, kan de methode append() worden gebruikt naast de methoden prompt() of promptStreaming() om aanvullende aanvullende contextuele prompts te geven nadat de sessie is gemaakt.

Voorbeeld:

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 promise die wordt geretourneerd door append() wordt uitgevoerd zodra de prompt is gevalideerd, verwerkt en toegevoegd aan de sessie. De promise wordt afgewezen als de prompt niet kan worden toegevoegd.

Een JSON-schema doorgeven

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

In het volgende voorbeeld zorgt het JSON-schema ervoor dat het model reageert met true of false 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 gestuurd. Dit gebruikt een deel van het contextvenster. Je kunt meten hoeveel van het contextvenster wordt gebruikt door de optie responseConstraint door te geven aan session.measureContextUsage().

Je kunt dit gedrag vermijden met de optie omitResponseConstraintInput. Als je dit doet, raden we je aan om wat richtlijnen in de prompt 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 });

Het model prompten

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

Uitvoer op basis van verzoeken

Als je een kort resultaat verwacht, kun je de functie prompt() gebruiken die de reactie retourneert zodra deze 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 je een langere reactie verwacht, gebruik je de functie promptStreaming(). Hiermee kun je gedeeltelijke resultaten tonen terwijl ze binnenkomen van het model. De functie promptStreaming() 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);
  }
}

Prompt stoppen

Zowel prompt() als promptStreaming() accepteren een optionele 2e parameter met een signal-veld, waarmee je 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 voor toekomstige interacties totdat het contextvenster van de sessie vol is.

Elke sessie heeft een maximumaantal tokens dat kan worden verwerkt. Check je voortgang richting deze limiet met het volgende:

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

Het is mogelijk om een prompt te sturen die ervoor zorgt dat het contextvenster overloopt. In dergelijke gevallen worden de eerste delen van het gesprek met het taalmodel verwijderd, één prompt en reactiepaar per keer, totdat er voldoende tokens beschikbaar zijn om de nieuwe prompt te verwerken. De uitzondering is de systeemprompt, die nooit wordt verwijderd.

U kunt zulke overstromingen detecteren door te luisteren naar de gebeurtenis contextoverflow in 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, mislukt de aanroep van prompt() of promptStreaming() met een uitzondering QuotaExceededError en wordt er niets verwijderd. De QuotaExceededError heeft de volgende eigenschappen:

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

Meer informatie over sessiebeheer.

Een sessie klonen

Als je resources wilt behouden, kun je een bestaande sessie kopiëren met de functie clone(). Hiermee maak je een vertakking van het gesprek, waarbij de context en de eerste prompt behouden blijven.

De functie clone() gebruikt een optioneel object met opties met een veld signal, waarmee u een AbortSignal kunt doorgeven om de gekloonde sessie te vernietigen.

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

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

Een sessie beëindigen

Roep destroy() aan om bronnen vrij te geven als je een sessie niet meer nodig hebt. Als een sessie wordt vernietigd, kan deze niet meer worden gebruikt en wordt de lopende uitvoering afgebroken. Je kunt de sessie bewaren als je van plan bent om het model vaak te prompten, omdat het maken 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 meerdere demo's gemaakt om de vele use cases voor de Prompt API te verkennen. De volgende demo's zijn web-apps:

Installeer de demo-extensie om de Prompt API in Chrome-extensies te testen. De broncode van de extensie is beschikbaar op GitHub.

Prestatiestrategie

De Prompt API voor het web wordt nog ontwikkeld. Terwijl we deze API ontwikkelen, kun je onze best practices voor sessiebeheer raadplegen voor optimale prestaties.

Rechtenbeleid, iframes en web workers

De Prompt API is standaard alleen beschikbaar voor vensters op het hoogste niveau en voor hun same-origin iframes. Toegang tot de API kan worden gedelegeerd aan cross-origin iframes met het kenmerk Permission Policy allow="":

<!--
  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 op dit moment niet beschikbaar in Web Workers, vanwege de complexiteit van het opstellen van een verantwoord document voor elke worker om de status van het rechtenbeleid te controleren.

Deelnemen en feedback delen

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