Prompt API

Thomas Steiner

Alexandra Klepper

Data publikacji: 20 maja 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. W aplikacji internetowej lub witrynie możesz 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

Przed użyciem tego interfejsu API zapoznaj się z zasadami Google dotyczącymi niedozwolonych zastosowań generatywnej AI i potwierdź, że je akceptujesz.

W przestrzeni nazw LanguageModel dostępne są 2 funkcje:

• availability(), aby sprawdzić, co potrafi model i czy jest dostępny.
• create(), aby rozpocząć sesję modelu językowego.

Pobieranie modelu

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 asynchroniczną funkcję LanguageModel.availability(). Powinna zostać zwrócona jedna z tych odpowiedzi:

• "unavailable" oznacza, że implementacja nie obsługuje żądanych opcji lub w ogóle nie obsługuje promptów dla modelu językowego.
• "downloadable" oznacza, że implementacja obsługuje żądane opcje, ale przed utworzeniem sesji z ich użyciem musi pobrać pewne dane (np. model językowy lub dostrajanie).
• "downloading" oznacza, że wdrożenie obsługuje żądane opcje, ale przed utworzeniem sesji z ich użyciem musi zakończyć trwającą operację pobierania.
• "available" oznacza, że implementacja obsługuje wybrane opcje bez konieczności pobierania nowych plików.

Aby wywołać pobieranie modelu i utworzyć sesję modelu językowego, wywołaj asynchroniczną funkcję LanguageModel.create(). Jeśli odpowiedź na availability() to 'downloadable', zalecamy sprawdzanie postępu pobierania. Dzięki temu możesz poinformować użytkownika, jeśli pobieranie zajmie trochę czasu.

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

Możliwości modelu

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

• defaultTopK: domyślna wartość parametru top-K (domyślnie: 3).
• maxTopK: wartość maksymalnego K (8).
• defaultTemperature: domyślna temperatura (1.0). Wartość temperatury musi się mieścić w zakresie od 0.0 do 2.0.
• maxTemperature: maksymalna temperatura.

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

Tworzenie sesji

Gdy interfejs Prompt API będzie mógł działać, utwórz sesję za pomocą funkcji create(). Możesz użyć funkcji prompt() lub promptStreaming().

Dostosowywanie sesji

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

Prompty początkowe

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 przez podanie prefiksu

Możesz dodać nową 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 określeniu formatu odpowiedzi modelu językowego. Aby to zrobić, dodaj znak prefix: true do końcowego komunikatu 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 bez monitowania

Wnioskowanie może zająć trochę czasu, zwłaszcza w przypadku promptów z danymi 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.

Ograniczenia sesji

Sesja danego modelu językowego ma maksymalną liczbę tokenów, które może przetworzyć. Zużycie i postępy w osiąganiu tego limitu możesz sprawdzić, korzystając z tych właściwości obiektu sesji:

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

Trwałość sesji

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

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

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

Strumieniowane dane wyjściowe

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

Zatrzymywanie działania 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 unsure between a
  t-shirt and a polo."
);

Możliwości multimodalne

Interfejs Prompt API obsługuje dane wejściowe audio i obrazy z Chrome 138 Canary na potrzeby lokalnych eksperymentów. 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" } is not necessary to include explicitly, unless
  // you also want to include expected input languages for text.
  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 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 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 },
    ],
  },
]);

Wersje demonstracyjne multimodalne

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

Prześlij opinię

Twoja opinia pomoże nam w przyszłości ulepszać ten interfejs API i Gemini Nano. Może to nawet doprowadzić do powstania specjalnych interfejsów API do wykonywania zadań (np. interfejsów API do transkrypcji dźwięku lub opisu obrazów), dzięki czemu będziemy mogli spełniać Twoje potrzeby i potrzeby Twoich użytkowników.

Uczestniczenie w programie i przesyłanie opinii

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

• Dołącz do programu wcześniejszego dostępu
• 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.
• Weź udział w pracach nad standardami, dołączając do Web Incubator Community Group.