Prompt API

Thomas Steiner

Alexandra Klepper

Data publikacji: 20 maja 2025 r., ostatnia aktualizacja: 21 września 2025 r.

Wyjaśnienie	Sieć	Rozszerzenia	Stan Chrome	Intencja
GitHub	W okresie próbnym	Chrome 138	Wyświetl	Zamiar przeprowadzenia eksperymentu

Za pomocą interfejsu Prompt API możesz wysyłać do Gemini Nano w przeglądarce żą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: odpowiadanie 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 treści.
• Filtry treści niestandardowych analizować artykuły informacyjne i automatycznie rozmywać lub ukrywać 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 zaledwie kilku krokach.
• Bezproblemowe wyodrębnianie kontaktów Utwórz rozszerzenie, które wyodrębnia dane 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 stworzysz.

Korzystanie z interfejsu Prompt API

Interfejs Prompt API korzysta w Chrome z modelu Gemini Nano. Interfejs API jest wbudowany w Chrome, ale model jest pobierany osobno, gdy po raz pierwszy używa go dana domena. Przed użyciem tego interfejsu API zapoznaj się z zasadami Google dotyczącymi niedozwolonych zastosowań generatywnej AI.

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

const availability = await LanguageModel.availability();

Zanim będzie można pobrać model, musi nastąpić interakcja użytkownika, np. kliknięcie, dotknięcie lub naciśnięcie klawisza.

Jeśli odpowiedź to downloadable lub downloading, model i interfejsy API są dostępne, ale przed użyciem funkcji trzeba je pobrać. Aby zezwolić na pobieranie, użytkownik musi wejść w interakcję ze stroną (np. kliknąć ją, dotknąć lub nacisnąć klawisz).

Aby pobrać i utworzyć instancję modelu, 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, sprawdź postęp pobierania i poinformuj o nim użytkownika, ponieważ pobieranie może zająć trochę czasu.

Parametry modelu

Funkcja params() informuje o parametrach modelu językowego. Obiekt zawiera te pola:

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

await LanguageModel.params();
// {defaultTopK: 3, maxTopK: 128, defaultTemperature: 1, maxTemperature: 2}

Tworzenie sesji

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

Każdą sesję można dostosować za pomocą parametrów topK i temperature, używając opcjonalnego obiektu opcji. Domyślne wartości tych parametrów są zwracane z LanguageModel.params().

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

Opcjonalny obiekt opcji funkcji create() zawiera też pole signal, które umożliwia przekazanie wartości AbortSignal w celu zakończenia sesji.

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

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

Dodawanie kontekstu za pomocą początkowych promptów

Za pomocą wstępnych promptów możesz przekazywać modelowi językowemu kontekst 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ć "assistant" rolę, 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ą "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 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 expectedInputs i expectedOutputs tryby oraz języki.

• type: oczekiwana modalność.
  • W przypadku expectedInputs może to być text, image lub audio.
  • W przypadku expectedOutputs interfejs Prompt API umożliwia tylko text.
• languages: tablica, w której należy ustawić oczekiwany język lub języki. Interfejs Prompt API akceptuje wartości "en", "ja" i "es". Pracujemy nad obsługą kolejnych języków.
  • W przypadku expectedInputs ustaw język prompta systemowego i co najmniej 1 oczekiwany język prompta 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ć wyjątek "NotSupportedError" DOMException.

Możliwości multimodalne

Dzięki tym funkcjom możesz:

• Zezwalaj użytkownikom na transkrypcję wiadomości audio wysłanych w aplikacji do czatowania.
• 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.

Dołączanie wiadomości

Wnioskowanie może zająć trochę czasu, zwłaszcza w przypadku promptów z danymi wejściowymi multimodalnymi. Wysyłanie z wyprzedzeniem wstępnie określonych promptów w celu wypełnienia sesji może być przydatne, ponieważ model może wtedy szybciej rozpocząć przetwarzanie.

initialPrompts są przydatne podczas tworzenia sesji, ale metody append() można używać w połączeniu z metodami prompt() lub promptStreaming(), aby po utworzeniu sesji podawać dodatkowe podpowiedzi 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() zostanie spełniona po zweryfikowaniu, przetworzeniu i dodaniu promptu do sesji. Obietnica jest odrzucana, jeśli nie można dołączyć prompta.

Przekazywanie schematu JSON

Dodaj pole responseConstraint do metody prompt() lub promptStreaming(), aby przekazać schemat JSON jako wartość. Następnie możesz użyć danych wyjściowych w formacie strukturalnym w interfejsie 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

W ramach wiadomości wysyłanej do modelu możesz uwzględnić schemat JSON lub wyrażenie regularne. Wykorzystuje to część limitu danych wejściowych. Możesz zmierzyć, ile limitu danych wejściowych zostanie wykorzystane, przekazując opcję responseConstraint do session.measureInputUsage().

Możesz uniknąć tego zachowania, korzystając z 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 });

Wysyłanie promptów do modelu

Możesz użyć funkcji prompt() lub promptStreaming().

Dane wyjściowe bez przesyłania strumieniowego

Jeśli oczekujesz krótkiego wyniku, możesz użyć funkcji prompt(), która zwraca odpowiedź, gdy tylko 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 { defaultTemperature, maxTemperature, defaultTopK, maxTopK } =
  await LanguageModel.params();

const available = await LanguageModel.availability();

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 otrzymywania z modelu. Funkcja promptStreaming() zwraca wartość ReadableStream.

const { defaultTemperature, maxTemperature, defaultTopK, maxTopK } =
  await LanguageModel.params();

const available = await LanguageModel.availability();
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);
  }
}

Zakończ pisanie prompta

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

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

console.log(`${session.inputUsage}/${session.inputQuota}`);

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

Klonowanie sesji

Aby zachować zasoby, możesz sklonować istniejącą sesję za pomocą funkcji clone(). Kontekst rozmowy zostanie zresetowany, ale początkowy prompt pozostanie bez zmian. Funkcja clone() przyjmuje opcjonalny obiekt opcji z polem signal, które umożliwia przekazanie funkcji 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 nie potrzebujesz już sesji, zadzwoń pod numer destroy(), aby zwolnić zasoby. Po zniszczeniu sesji nie można jej już używać, a wszystkie trwające wykonania są przerywane. Jeśli zamierzasz często wysyłać prompt do modelu, 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."
);

Przykłady

Przygotowaliśmy kilka wersji demonstracyjnych, aby zaprezentować różne zastosowania interfejsu Prompt API. Te wersje demonstracyjne to aplikacje internetowe:

• Platforma testowa Prompt API
• Komunikat audio Mediarecorder
• Prompt do obrazu 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 skuteczności

Interfejs Prompt API na potrzeby internetu jest w trakcie opracowywania. Podczas tworzenia tego interfejsu API zapoznaj się ze sprawdzonymi metodami 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 w oknach najwyższego poziomu i w ramkach iframe z tej samej domeny. Dostęp do interfejsu API można delegować na elementy iframe z innych domen za pomocą atrybutu allow="" zasad 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 przypadku Web Workers ze względu na złożoność procesu tworzenia odpowiedzialnego dokumentu dla każdego pracownika w celu sprawdzenia stanu zasad dotyczących uprawnień.

Uczestniczenie w programie i przesyłanie opinii

Twoje opinie mogą bezpośrednio wpłynąć na sposób, w jaki 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ą o kształcie interfejsu API, komentując istniejące zgłoszenie lub otwierając nowe w repozytorium Prompt API na GitHubie.
• Dołącz do programu wczesnego dostępu.