Prompt API

Thomas Steiner

Alexandra Klepper

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

Wyjaśnienie	Sieć	Rozszerzenia	Stan Chrome	Intencja
GitHub	Testowanie origin	Chrome 138	Wyświetl	Intencja eksperymentu
GitHub	Testowanie origin parametrów próbkowania	Chrome 148	Wyświetl	Intencja 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: 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: utwórz rozszerzenie 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 korzysta z modelu Gemini Nano w Chrome. Interfejs API jest wbudowany w Chrome, ale model jest pobierany oddzielnie, gdy punkt początkowy używa interfejsu API po raz pierwszy. Zanim zaczniesz korzystać z 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 LanguageModel.availability().

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

Aby uruchomić 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ć.

Korzystanie z localhost

Wszystkie wbudowane interfejsy AI API są dostępne w Chrome na localhost. Ustaw te flagi na Włączone:

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

Następnie kliknij Uruchom ponownie lub ponownie uruchom Chrome. Jeśli wystąpią błędy, rozwiąż problemy z localhost.

Parametry modelu

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

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

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

Utwórz sesję

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

const session = await LanguageModel.create();

Tworzenie sesji za pomocą interfejsu Prompt API dla rozszerzeń Chrome

Gdy używasz interfejsu Prompt API dla rozszerzeń Chrome, każdą sesję można dostosować za pomocą topK i temperature za pomocą opcjonalnego obiektu opcji. Domyślne wartości tych parametrów są zwracane przez 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,
});

Opcjonalny obiekt opcji funkcji create() zawiera też 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,
});

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żywanie 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, która umożliwia ustawienie oczekiwanego języka lub języków. Interfejs Prompt API akceptuje "en", "ja" i "es". Trwają prace nad obsługą dodatkowych języków.
  • W przypadku expectedInputs ustaw język prompta systemowego oraz 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 DOMException "NotSupportedError".

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 czatu,
• 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 element HTMLCanvasElement) i porównuje je za pomocą AI, 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 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(), aby po utworzeniu sesji przekazać 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() zostanie spełniona, gdy prompt zostanie zweryfikowany, przetworzony i dołączony do sesji. Obietnica zostanie odrzucona, 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żywać danych wyjściowych w uporządkowanej postaci za pomocą interfejsu Prompt API.

W tym przykładzie schemat JSON zapewnia, że model odpowie wartością 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

Wdrożenie może obejmować 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 będzie używane, przekazując opcję responseConstraint do session.measureContextUsage().

Możesz uniknąć tego zachowania za pomocą 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

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 elementów:

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 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ąć 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. Wyjątek QuotaExceededError ma te właściwości:

• 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 funkcję 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

Utworzyliśmy kilka prezentacji, aby zapoznać się z wieloma przypadkami 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 przekazać elementom iframe z innych domen za pomocą atrybutu zasad dotyczących 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ść ustanawiania odpowiedzialnego dokumentu dla każdego worker, aby sprawdzić stan 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 Chrome, zgłoś błąd lub 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 dostępu.