Prompt API

Thomas Steiner

Alexandra Klepper

Data publikacji: 20 maja 2025 r., ostatnia aktualizacja: 21 lipca 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.

Interfejs Prompt API możesz wykorzystać w aplikacji lub witrynie 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.

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

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.

Aby sprawdzić, czy model jest gotowy do użycia, wywołaj funkcję LanguageModel.availability(). Jeśli odpowiedź na pytanie availability() brzmiała downloadable, sprawdź postęp pobierania i poinformuj o nim użytkownika, ponieważ pobieranie może zająć trochę czasu.

const availability = await LanguageModel.availability();

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

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

Parametry modelu

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

• defaultTopK: domyślna wartość 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 options. 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ć 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ą "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,
  },
]);

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

Trwałość sesji i limity

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.

const session = await LanguageModel.create({
  initialPrompts: [
    {
      role: 'system',
      content:
        'You are a friendly, helpful assistant specialized in clothing choices.',
    },
  ],
});

const result1 = await session.prompt(
  'What should I wear today? It is sunny. I am unsure between a t-shirt and a polo.',
);
console.log(result1);

const result2 = await session.prompt(
  'That sounds great, but oh no, it is actually going to rain! New advice?',
);
console.log(result2);

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

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

Wdrożenie może obejmować schemat JSON lub wyrażenie regularne jako część wiadomości wysyłanej do modelu. 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, wybierając opcję 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 });

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

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

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

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

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

Możliwości multimodalne

Testowanie origin interfejsu Prompt API obsługuje dane wejściowe w postaci dźwięku i obrazu. Interfejs API zwraca tekstowe dane wyjściowe.

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.

const session = await LanguageModel.create({
  // { type: 'text' } only required when including expected input languages.
  expectedInputs: [{ type: 'audio' }, { type: 'image' }],
});

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 an artistic critique of how well the second image matches the first:',
      },
      { type: 'image', value: referenceImage },
      { type: 'image', value: userDrawnImage },
    ],
  },
]);

console.log(response1);

const audioBlob = await captureMicrophoneInput({ seconds: 10 });

const response2 = await session.prompt([
  {
    role: 'user',
    content: [
      { type: 'text', value: 'My response to your critique:' },
      { type: 'audio', value: audioBlob },
    ],
  },
]);

Aby dowiedzieć się, jak używać interfejsu Prompt API z danymi wejściowymi audio, zapoznaj się z demonstracją Mediarecorder Audio Prompt. Aby dowiedzieć się, jak używać interfejsu Prompt API z danymi wejściowymi obrazu, zapoznaj się z demonstracją Canvas Image Prompt.

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 odpowiedniego 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ą na temat kształtu 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.