Prompt API

Thomas Steiner

Alexandra Klepper

Opublikowano: 20 maja 2025 r., ostatnia aktualizacja: 26 sierpnia 2026 r.

Film z wyjaśnieniem	Sieć	Rozszerzenia	Stan Chrome	Intencja
GitHub	Chrome 148	Chrome 138	Wyświetl	Intencja wysłania
GitHub	Testowanie origin parametrów próbkowania	Chrome 148	Wyświetl	Intencja przeprowadzenia eksperymentu

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

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 wiadomości: utwórz kanał, który dynamicznie klasyfikuje artykuły według kategorii i umożliwia użytkownikom filtrowanie treści.
• Niestandardowe filtry treści: analizuj artykuły i automatycznie rozmazuj lub ukrywaj 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 wydarzenia ze stron internetowych, dzięki czemu użytkownicy mogą tworzyć wpisy w kalendarzu w zaledwie kilku krokach.
• Bezproblemowe wyodrębnianie kontaktów: utwórz rozszerzenie, które wyodrębnia informacje kontaktowe z witryn, ułatwiając użytkownikom kontakt z firmą lub dodawanie szczegółów do listy kontaktów.

To tylko kilka możliwości. Cieszymy się, że możemy zobaczyć, co stworzysz.

Korzystanie z interfejsu Prompt API

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

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 rozpocząć pobieranie i utworzyć instancję modelu językowego, sprawdź aktywację 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 availability() to downloading, nasłuchuj postępu pobierania i informuj o nim użytkownika, ponieważ pobieranie może potrwać.

Utwórz sesję

Gdy interfejs Prompt API może działać, utwórz sesję za pomocą funkcji create().

const session = await LanguageModel.create();

Opcjonalny obiekt opcji funkcji create() zawiera 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

{: #sampling_parameters }

Kontrolowanie próbkowania pozwala dostosować przewidywalność (determinizm) lub kreatywność (różnorodność) odpowiedzi modelu. Dostępność parametrów próbkowania różni się w zależności od platformy internetowej i rozszerzeń Chrome:

• Internet (domyślnie): domyślnie interfejs Prompt API w internecie nie udostępnia parametrów próbkowania, ponieważ ustawienia liczbowe, takie jak temperature i topK nie są spójne w różnych modelach i architekturach.
• Internet (test pochodzenia): test pochodzenia odblokowuje opcję samplingMode, która używa opisowych wartości wyliczeniowych zamiast surowych liczb do dostosowania przewidywalności danych wyjściowych.
• Rozszerzenia Chrome: obsługiwane są starsze parametry liczbowe (topK, temperature) i metoda LanguageModel.params().

Tryb próbkowania w internecie (testowanie origin)

Jeśli bierzesz udział w teście pochodzenia parametrów próbkowania, możesz przekazać opcję samplingMode do LanguageModel.create() (lub LanguageModel.availability()).

Obsługiwane wartości wyliczeniowe samplingMode to:

• "most-predictable": najwyższy determinizm i przewidywalność.
• "predictable": bardziej przewidywalne dane wyjściowe z minimalnymi zmianami.
• "slightly-predictable": nieco przewidywalne dane wyjściowe.
• "balanced": równowaga między przewidywalnością a kreatywnością (typowe domyślne działanie).
• "slightly-creative": nieco zróżnicowane i kreatywne dane wyjściowe.
• "creative": kreatywne i zróżnicowane dane wyjściowe.
• "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 w rozszerzeniach Chrome

Gdy używasz interfejsu Prompt API w rozszerzeniach Chrome, każdą sesję można nadal dostosowywać za pomocą topK i temperature za pomocą obiektu opcji.

Statyczna funkcja 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ą początkowych promptów

Za pomocą początkowych promptów 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

Oprócz poprzednich ról 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 rolą "assistant". Może to pomóc w nakierowaniu modelu językowego na użycie określonego formatu odpowiedzi. Aby to zrobić, dodaj prefix: true do końcowej wiadomości z rolą "assistant". 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 możliwości multimodalne i obsługuje wiele języków. Podczas tworzenia sesji ustaw modalności i języki expectedInputs i expectedOutputs.

• type: oczekiwana modalność.
  • W przypadku expectedInputs może to być text, image lub audio.
  • W przypadku expectedOutputs interfejs Prompt API obsługuje tylko text.
• languages: tablica, w której można ustawić oczekiwany język lub języki. Interfejs Prompt API akceptuje "en", "ja", "es", "de" i "fr". Pracujemy nad obsługą dodatkowych języków.
  • W przypadku expectedInputs ustaw język promptu systemowego oraz 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żesz otrzymać "NotSupportedError" DOMException.

Możliwości multimodalne

Dzięki tym możliwościom możesz:

• umożliwić użytkownikom transkrypcję wiadomości audio wysyłanych w aplikacji do czatowania,
• opisać obraz przesłany do witryny, aby użyć go w podpisie lub tekście alternatywnym.

Aby dowiedzieć się, jak używać interfejsu Prompt API z wejściem audio, zapoznaj się z prezentacją Mediarecorder Audio Prompt , a aby dowiedzieć się, jak używać interfejsu Prompt API z wejściem obrazu, zapoznaj się z prezentacją Canvas Image Prompt.

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

• Audio:
  • AudioBuffer
  • ArrayBufferView
  • ArrayBuffer
  • Blob
• Obraz:
  • HTMLImageElement
  • SVGImageElement
  • HTMLVideoElement (używa klatki wideo w bieżącej pozycji wideo)
  • HTMLCanvasElement
  • ImageBitmap
  • OffscreenCanvas
  • VideoFrame
  • Blob
  • ImageData

Ten fragment kodu pokazuje sesję multimodalną, która najpierw przetwarza 2 obrazy (1 obraz Blob i 1 obraz HTMLCanvasElement) i porównuje je za pomocą AI, a następnie umożliwia użytkownikowi odpowiedź za pomocą nagrania dźwiękowego (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 multimodalnymi. Warto z wyprzedzeniem wysłać wstępnie określone prompty, aby wypełnić sesję, dzięki czemu model może wcześniej rozpocząć przetwarzanie.

O ile initialPrompts są przydatne podczas tworzenia sesji, o tyle metody append() można używać oprócz metod prompt() lub promptStreaming() do przekazywania dodatkowych promptów kontekstowych po utworzeniu sesji.

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() zostanie spełniona, gdy prompt zostanie zweryfikowany, przetworzony i dołączony do sesji. Obietnica zostanie odrzucona, jeśli nie można dołączyć promptu.

Przekazywanie schematu JSON

Dodaj pole responseConstraint do metody prompt() lub promptStreaming(), aby przekazać schemat JSON jako wartość. Następnie możesz używać danych wyjściowych o uporządkowanej strukturze 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. Wykorzystuje to część okna kontekstu. Możesz zmierzyć, ile okna kontekstu zostanie użyte, przekazując opcję responseConstraint do session.measureContextUsage().

Możesz uniknąć tego zachowania za pomocą opcji omitResponseConstraintInput. Jeśli to zrobisz, zalecamy dodanie do promptu 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

Model możesz promptować za pomocą funkcji prompt() lub promptStreaming().

Dane wyjściowe oparte na żądaniach

Jeśli oczekujesz krótkiego wyniku, możesz użyć funkcji prompt(), która zwraca odpowiedź, gdy jest 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 oczekujesz dłuższej odpowiedzi, użyj funkcji promptStreaming(), która umożliwia wyświetlanie częściowych wyników w miarę ich otrzymywania z modelu. 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);
  }
}

Zatrzymywanie promptowania

Zarówno prompt(), jak i promptStreaming() akceptują opcjonalny drugi parametr z polem signal, który umożliwia zatrzymanie 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. Podczas przyszłych interakcji uwzględniane są poprzednie interakcje, dopóki okno kontekstu sesji nie zostanie zapełnione.

Każda sesja ma maksymalną liczbę tokenów, które może przetworzyć. Postęp w osiąganiu tego limitu możesz sprawdzić za pomocą tych metod:

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

Możesz wysłać prompt, który spowoduje przepełnienie okna kontekstu. W takich przypadkach początkowe części rozmowy z modelem językowym będą usuwane po jednym prompcie i odpowiedzi, aż będzie dostępna wystarczająca liczba tokenów do przetworzenia nowego promptu. 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ąć wystarczającej liczby tokenów z historii rozmowy, aby przetworzyć nowy prompt, wywołanie prompt() lub promptStreaming() zakończy się niepowodzeniem z wyjątkiem QuotaExceededError i nic nie zostanie usunięte. Właściwości QuotaExceededError:

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

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 rozwidlenia 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 AbortSignal w celu zniszczenia sklonowanej sesji.

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

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

Zakończ sesję

Jeśli sesja nie jest już potrzebna, wywołaj destroy(), aby zwolnić zasoby. Po zniszczeniu sesji nie można jej już używać, a wszystkie trwające wykonania zostaną przerwane. Jeśli zamierzasz często promptować model, warto 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

Przygotowaliśmy kilka prezentacji, aby pokazać wiele przypadków użycia interfejsu Prompt API. Te prezentacje to aplikacje internetowe:

• Plac zabaw Prompt API
• Prompt audio Mediarecorder
• Prompt obrazu Canvas

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

Strategia dotycząca skuteczności

Interfejs Prompt API dla internetu jest nadal w fazie rozwoju. Podczas tworzenia tego interfejsu API, zapoznaj się ze sprawdzonymi metodami zarządzania sesjami aby uzyskać optymalną skuteczność.

Zasady dotyczące uprawnień, elementy iframe i Web Workers

Domyślnie interfejs Prompt API jest dostępny tylko w oknach najwyższego poziomu i ich elementach iframe z tej samej domeny. Dostęp do interfejsu API można delegować do elementów iframe ze współdzieleniem za pomocą atrybutu allow="" w zasadach dotyczących uprawnień:

<!--
  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ść ustanawiania odpowiedzialnego dokumentu dla każdego workera w celu sprawdzenia stanu zasad dotyczących uprawnień.

Uczestniczenie i przesyłanie opinii

Twoje opinie mogą bezpośrednio wpłynąć na sposób tworzenia i wdrażania przyszłych wersji tego interfejsu API oraz wszystkich wbudowanych interfejsów AI API.

• Aby przesłać opinię na temat implementacji w Chrome, zgłoś błąd lub prześlij prośbę 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 wczesnego testowania.