Prompt API

Thomas Steiner

Alexandra Klepper

Data publikacji: 20 maja 2025 r., ostatnia aktualizacja: 21 października 2026 r.

Wyjaśnienie	Sieć	Rozszerzenia	Stan Chrome	Intencja
GitHub	Chrome 148	Chrome 138	Wyświetl	Intent to Ship
GitHub	Testowanie origin parametrów próbkowania	Chrome 148	Wyświetl	Zamiar przeprowadzenia eksperymentu

Za pomocą interfejsu Prompt API możesz wysyłać do modelu podstawowego w Chrome żądania w języku naturalnym.

Interfejsu Prompt API można używać na wiele sposobów. Możesz na przykład utworzyć:

• Wyszukiwanie oparte na AI: odpowiadaj na pytania na podstawie treści strony internetowej.
• Spersonalizowane kanały wiadomości: utwórz kanał, który dynamicznie klasyfikuje artykuły według kategorii i umożliwia użytkownikom filtrowanie tych treści.
• Niestandardowe filtry treści. Analizowanie artykułów z wiadomościami i automatyczne rozmywanie lub ukrywanie treści na podstawie tematów zdefiniowanych przez użytkownika.
• Tworzenie wydarzeń w kalendarzu. Opracuj rozszerzenie do Chrome, które automatycznie wyodrębnia szczegóły wydarzeń ze stron internetowych, dzięki czemu użytkownicy mogą tworzyć wpisy w kalendarzu w kilku krokach.
• Bezproblemowe wyodrębnianie kontaktów. Utwórz rozszerzenie, które wyodrębnia informacje kontaktowe ze stron internetowych, ułatwiając użytkownikom kontakt z firmą lub dodawanie szczegółów do listy kontaktów.

To tylko kilka możliwości. Jesteśmy ciekawi, co uda Ci się stworzyć.

Korzystanie z Prompt API

Prompt API używa modelu Gemini Nano w Chrome. Interfejs API jest wbudowany w Chrome, ale model jest pobierany osobno, gdy źródło po raz pierwszy używa interfejsu API.

Aby sprawdzić, czy model jest gotowy do użycia, wywołaj LanguageModel.availability().

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

Aby uruchomić pobieranie i utworzyć instancję modelu językowego, sprawdź aktywność użytkownika. Następnie wywołaj funkcję create().

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

Jeśli odpowiedź na pytanie availability() brzmiała downloading, poczekaj na postęp pobierania i poinformuj użytkownika, ponieważ pobieranie może trochę potrwać.

Tworzenie sesji

Gdy interfejs Prompt API będzie mógł działać, utwórz sesję za pomocą funkcji create().

const session = await LanguageModel.create();

Opcjonalny obiekt opcji funkcji create() przyjmuje pole signal, które umożliwia przekazanie AbortSignal w celu zniszczenia sesji.

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

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

Parametry próbkowania

Kontrolowanie próbkowania pozwala dostosować stopień przewidywalności (determinizmu) lub kreatywności (różnorodności) odpowiedzi modelu. Dostępność parametrów próbkowania różni się między platformą internetową a rozszerzeniami do Chrome:

• Internet: użyj opcji samplingMode, która wykorzystuje opisowe wartości wyliczeniowe zamiast nieprzetworzonych liczb, aby dostosować przewidywalność danych wyjściowych.
• Rozszerzenia do Chrome: obsługiwane są starsze parametry liczbowe (topK, temperature) i metoda LanguageModel.params().

Tryb próbkowania w internecie

Przekaż opcję samplingMode do LanguageModel.create() (lub LanguageModel.availability()).

Obsługiwane wartości typu wyliczeniowego samplingMode to:

• "most-predictable": najwyższy poziom determinizmu i przewidywalności.
• "predictable": bardziej przewidywalne wyniki z minimalnymi zmianami.
• "slightly-predictable": nieco przewidywalne dane wyjściowe.
• "balanced": równowaga między przewidywalnością a kreatywnością (typowe działanie domyślne).
• "slightly-creative": nieco zróżnicowane i kreatywne wyniki.
• "creative": kreatywne i zróżnicowane wyniki.
• "most-creative": maksymalna zmienność i kreatywność.

// 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"

Parametry próbkowania rozszerzeń do Chrome

Podczas korzystania z Prompt API w rozszerzeniach do Chrome każdą sesję można dostosować za pomocą topK i temperature, używając obiektu opcji.

Funkcja statyczna LanguageModel.params() informuje o domyślnych i maksymalnych limitach parametrów modelu językowego:

• defaultTopK: domyślna wartość top-K.
• maxTopK: maksymalna wartość top-K.
• defaultTemperature: domyślna temperatura.
• maxTemperature: maksymalna temperatura.

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

Dodawanie kontekstu za pomocą promptów początkowych

Dzięki promptom początkowym możesz przekazać modelowi językowemu kontekst dotyczący poprzednich interakcji, np. aby umożliwić użytkownikowi wznowienie zapisanej sesji po ponownym uruchomieniu przeglądarki.

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

Ograniczanie odpowiedzi za pomocą prefiksu

Możesz dodać rolę "assistant", aby rozwinąć poprzednie odpowiedzi modelu. Na przykład:

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

W niektórych przypadkach zamiast prosić o nową odpowiedź, możesz wstępnie wypełnić część wiadomości z odpowiedzią roli "assistant". Może to być przydatne, aby nakierować model językowy na użycie określonego formatu odpowiedzi. Aby to zrobić, dodaj prefix: true do końcowej wiadomości "assistant"-role. Na przykład:

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

Dodawanie oczekiwanych danych wejściowych i wyjściowych

Interfejs Prompt API ma funkcje multimodalne i obsługuje wiele języków. Podczas tworzenia sesji ustaw modalności i języki expectedInputs i expectedOutputs.

• type: oczekiwano modalności.
  • W przypadku expectedInputs może to być text, image lub audio.
  • W przypadku expectedOutputs interfejs Prompt API zezwala tylko na text.
• languages: tablica do ustawiania oczekiwanego języka lub języków. Prompt API akceptuje te parametry: "en", "ja", "es", "de" i "fr". Pracujemy nad obsługą kolejnych języków.
  • W przypadku expectedInputs ustaw język promptu systemowego i co najmniej 1 oczekiwany język promptu użytkownika.
  • Ustaw co najmniej 1 język expectedOutputs.

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

Jeśli model napotka nieobsługiwane dane wejściowe lub wyjściowe, może wystąpić wyjątek DOMException "NotSupportedError".

Możliwości multimodalne

Dzięki tym funkcjom możesz:

• Zezwalaj użytkownikom na transkrypcję wiadomości głosowych wysyłanych w aplikacji do czatu.
• Opisz obraz przesłany do witryny, aby użyć go w podpisie lub tekście alternatywnym.

Zapoznaj się z demonstracją Mediarecorder Audio Prompt, aby dowiedzieć się, jak używać interfejsu Prompt API z danymi wejściowymi audio, oraz z demonstracją Canvas Image Prompt, aby dowiedzieć się, jak używać interfejsu Prompt API z danymi wejściowymi w postaci obrazu.

Interfejs Prompt API obsługuje te typy danych wejściowych:

• Dźwięk:
  • AudioBuffer
  • ArrayBufferView
  • ArrayBuffer
  • Blob
• Wizualne:
  • HTMLImageElement
  • SVGImageElement
  • HTMLVideoElement (używa klatki filmu w bieżącej pozycji filmu)
  • HTMLCanvasElement
  • ImageBitmap
  • OffscreenCanvas
  • VideoFrame
  • Blob
  • ImageData

Ten fragment kodu przedstawia sesję multimodalną, która najpierw przetwarza 2 elementy wizualne (1 obraz Blob i 1 HTMLCanvasElement) i zleca AI ich porównanie, a następnie umożliwia użytkownikowi odpowiedź za pomocą nagrania dźwiękowego (jako 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);

Dołączanie wiadomości

Wnioskowanie może zająć trochę czasu, zwłaszcza w przypadku promptów z danymi wejściowymi w trybie multimodalnym. Warto wysłać wcześniej określone prompty, aby wypełnić sesję i umożliwić modelowi szybsze rozpoczęcie przetwarzania.

initialPrompts są przydatne podczas tworzenia sesji, ale oprócz metod prompt() i promptStreaming() można używać metody append(), aby po utworzeniu sesji podawać dodatkowe prompty kontekstowe.

Na przykład:

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

Obietnica zwrócona przez append() zostaje spełniona po zweryfikowaniu, przetworzeniu i dołączeniu prompta do sesji. Jeśli nie można dołączyć prompta, obietnica zostanie odrzucona.

Przekazywanie schematu JSON

Dodaj pole responseConstraint do metody prompt() lub promptStreaming(), aby przekazać schemat JSON jako wartość. Następnie możesz używać ustrukturyzowanych danych wyjściowych z interfejsem Prompt API.

W tym przykładzie schemat JSON zapewnia, że model odpowie true lub false, aby określić, czy dana wiadomość dotyczy ceramiki.

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

Implementacja może zawierać schemat JSON lub wyrażenie regularne jako część wiadomości wysyłanej do modelu. Zajmuje to część okna kontekstu. Możesz zmierzyć, jaką część okna kontekstu wykorzysta, przekazując opcję responseConstraint do session.measureContextUsage().

Możesz tego uniknąć, używając opcji omitResponseConstraintInput. Jeśli to zrobisz, zalecamy dodanie do prompta wskazówek:

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

Promptowanie modelu

Możesz wysłać prompta do modelu za pomocą funkcji prompt() lub promptStreaming().

Dane wyjściowe oparte na żądaniach

Jeśli spodziewasz się krótkiego wyniku, możesz użyć funkcji prompt(), która zwraca odpowiedź, gdy tylko jest ona dostępna.

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

Dane wyjściowe przesyłane strumieniowo

Jeśli spodziewasz się dłuższej odpowiedzi, użyj funkcji promptStreaming(), która umożliwia wyświetlanie częściowych wyników w miarę ich generowania przez model. Funkcja promptStreaming() zwraca 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);
  }
}

Zacznij pisać prompta

Zarówno prompt(), jak i promptStreaming() akceptują opcjonalny drugi parametr z polem signal, który umożliwia zatrzymanie uruchamiania promptów.

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

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

Zarządzanie sesją

Każda sesja śledzi kontekst rozmowy. Poprzednie interakcje są brane pod uwagę w przypadku przyszłych interakcji, dopóki okno kontekstu sesji nie zostanie zapełnione.

Każda sesja ma maksymalną liczbę tokenów, które może przetworzyć. Postępy w osiąganiu tego limitu możesz sprawdzać w ten sposób:

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

Można wysłać prompt, który spowoduje przepełnienie okna kontekstu. W takich przypadkach początkowe fragmenty rozmowy z modelem językowym będą usuwane (po jednej parze prompt–odpowiedź), aż będzie dostępna wystarczająca liczba tokenów do przetworzenia nowego prompta. Wyjątkiem jest prompt systemowy, który nigdy nie jest usuwany.

Takie przepełnienia można wykryć, nasłuchując zdarzenia contextoverflow w sesji:

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

Jeśli nie można usunąć z historii rozmowy wystarczającej liczby tokenów, aby przetworzyć nowy prompt, wywołanie prompt() lub promptStreaming() zakończy się niepowodzeniem z wyjątkiem QuotaExceededError i nic nie zostanie usunięte. QuotaExceededError ma te właściwości:

• requested: liczba tokenów, z których składają się dane wejściowe;
• contextWindow: ile tokenów było dostępnych,

Dowiedz się więcej o zarządzaniu sesjami.

Klonowanie sesji

Aby zachować zasoby, możesz skopiować istniejącą sesję za pomocą funkcji clone(). Spowoduje to utworzenie rozgałęzienia rozmowy, w którym zachowany zostanie kontekst i początkowy prompt.

Funkcja clone() przyjmuje opcjonalny obiekt opcji z polem signal, które umożliwia przekazanie obiektu AbortSignal w celu zniszczenia sklonowanej sesji.

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

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

Zakończenie sesji

Jeśli nie potrzebujesz już sesji, wywołaj destroy(), aby zwolnić zasoby. Po zniszczeniu sesji nie można jej już używać, a wszystkie trwające wykonania zostają przerwane. Jeśli zamierzasz często wysyłać prompty do modelu, możesz zachować sesję, ponieważ jej utworzenie może zająć trochę czasu.

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

Prezentacje

Utworzyliśmy kilka wersji demonstracyjnych, aby zaprezentować wiele przypadków użycia interfejsu Prompt API. Te wersje demonstracyjne to aplikacje internetowe:

• Platforma testowa Prompt API
• Mediarecorder Audio Prompt
• Prompt graficzny w Canvas

Aby przetestować interfejs Prompt API w rozszerzeniach do Chrome, zainstaluj rozszerzenie demonstracyjne. Kod źródłowy rozszerzenia jest dostępny na GitHubie.

Strategia dotycząca skuteczności

Interfejs Prompt API dla przeglądarek jest nadal rozwijany. Podczas tworzenia tego interfejsu API zapoznaj się ze sprawdzonymi metodami dotyczącymi zarządzania sesjami, aby uzyskać optymalną wydajność.

Zasady dotyczące uprawnień, elementy iframe i skrypty Web Worker

Domyślnie interfejs Prompt API jest dostępny tylko dla okien najwyższego poziomu i ich elementów iframe tego samego pochodzenia. Dostęp do interfejsu API można przekazać elementom iframe ze współdzieleniem za pomocą atrybutu zasad uprawnień 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>

Interfejs Prompt API nie jest obecnie dostępny w Web Workers ze względu na złożoność tworzenia odpowiedzialnego dokumentu dla każdego worker w celu sprawdzenia stanu zgodności z zasadami.

Uczestnictwo i przesyłanie opinii

Twoje odpowiedzi mogą bezpośrednio wpłynąć na to, jak będziemy tworzyć i wdrażać przyszłe wersje tego interfejsu API oraz wszystkich wbudowanych interfejsów API AI.

• Jeśli chcesz przesłać opinię na temat implementacji Chrome, zgłoś błąd lub poproś o dodanie funkcji.
• Podziel się opinią na temat kształtu interfejsu API, komentując istniejący problem lub otwierając nowy w repozytorium Prompt API na GitHubie.
• Dołącz do programu wczesnej wersji przedpremierowej.