Prompt API

Thomas Steiner
Alexandra Klepper
Alexandra Klepper
GitHub Bluesky

Opublikowano: 20 maja 2025 r., ostatnia aktualizacja: 19 maja 2026 r.

Wyjaśnienie Sieć Rozszerzenia Stan Chrome Intencja
GitHub Chrome 148 Chrome 138 Wyświetl Intencja wysłania
GitHub Wersja próbna origin Test pochodzenia 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.

Interfejs Prompt API można wykorzystać 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 informacyjne: 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.

Sprawdź wymagania sprzętowe

Deweloperzy i użytkownicy, którzy korzystają z funkcji używających tych interfejsów API w Chrome, muszą spełniać te wymagania. Inne przeglądarki mogą mieć inne wymagania dotyczące działania.

Interfejsy Language Detector API i Translator API działają w Chrome na komputerze. Te interfejsy API nie działają na urządzeniach mobilnych.

Interfejsy Prompt API, Summarizer API, Writer API, Rewriter API i Proofreader API działają w Chrome, gdy spełnione są te warunki:

  • System operacyjny: Windows 10 lub 11; macOS 13 lub nowszy (Ventura i nowsze); Linux; ChromeOS (od platformy 16389.0.0) na Chromebookach Plus. Chrome na Androida, iOS i ChromeOS na urządzeniach innych niż Chromebooki Plus nie są jeszcze obsługiwane przez interfejsy API, które używają modeli podstawowych.
  • Miejsce na dane: co najmniej 22 GB wolnego miejsca na dysku, na którym znajduje się profil Chrome.
  • Procesor graficzny lub procesor: wbudowane modele mogą działać z procesorem graficznym lub procesorem.
    • Procesor graficzny: co najmniej 4 GB pamięci VRAM.
    • Procesor: co najmniej 16 GB pamięci RAM i co najmniej 4 rdzenie procesora.
    • Uwaga: interfejs Prompt API z wejściem audio wymaga procesora graficznego.
  • Sieć: nieograniczona transmisja danych lub połączenie bez limitu danych.

Dokładny rozmiar Gemini Nano może się różnić w zależności od aktualizacji modelu przez przeglądarkę. Aby sprawdzić bieżący rozmiar, otwórz stronę chrome://on-device-internals.

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

Parametry modelu

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

// 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 w przypadku rozszerzeń Chrome

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

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 audio (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 będzie mógł 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ć 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 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 funkcji 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 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ż do momentu, gdy 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

Przygotowaliśmy kilka prezentacji, aby pokazać różne przypadki użycia interfejsu Prompt API. Te prezentacje to aplikacje internetowe:

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 wciąż 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 w elementach iframe z tej samej domeny. Dostęp do interfejsu API można delegować do elementów iframe z innych domen 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 procesu roboczego 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.