API Prompt

Thomas Steiner

Publié le 11 novembre 2024, dernière mise à jour le 20 mai 2025

Vidéo explicative	Web	Extensions	État de Chrome	Intent
GitHub	Dans EPP	Version bêta de Chrome 137	Afficher	Intent to Experiment

Avec l'API Prompt, vous pouvez envoyer des requêtes en langage naturel à Gemini Nano dans le navigateur.

Vous pouvez utiliser l'API Prompt de différentes manières dans les extensions Chrome. Exemple :

• Événements d'agenda instantanés Développez une extension Chrome qui extrait automatiquement les détails des événements à partir de pages Web afin que les utilisateurs puissent créer des entrées d'agenda en quelques étapes.
• Extraction de contacts fluide Créez une extension qui extrait les coordonnées des sites Web, ce qui permet aux utilisateurs de contacter plus facilement une entreprise ou d'ajouter des informations à leur liste de contacts.
• Filtrage dynamique du contenu Créez une extension Chrome qui analyse les articles d'actualité et floute ou masque automatiquement le contenu en fonction de sujets définis par l'utilisateur.

Ce ne sont là que quelques possibilités. Nous avons hâte de découvrir vos créations.

Utiliser l'API Prompt dans les extensions

Avant d'utiliser cette API, lisez le Règlement de Google sur les utilisations interdites de l'IA générative.

Deux fonctions d'extension sont disponibles dans l'espace de noms LanguageModel:

• availability() pour vérifier les fonctionnalités du modèle et s'il est disponible.
• create() pour démarrer une session de modèle de langage.

Téléchargement du modèle

L'API Prompt utilise le modèle Gemini Nano dans Chrome. Bien que l'API soit intégrée à Chrome, le modèle est téléchargé séparément la première fois qu'une extension utilise l'API.

Pour déterminer si le modèle est prêt à l'emploi, appelez la fonction LanguageModel.availability() asynchrone. Cette opération devrait renvoyer l'une des réponses suivantes:

• "unavailable" signifie que l'implémentation n'est pas compatible avec les options demandées ou qu'elle n'est pas du tout compatible avec l'invite d'un modèle de langue.
• "downloadable" signifie que l'implémentation est compatible avec les options demandées, mais qu'elle devra télécharger quelque chose (par exemple, le modèle de langage lui-même ou un réglage fin) avant de pouvoir créer une session à l'aide de ces options.
• "downloading" signifie que l'implémentation est compatible avec les options demandées, mais qu'elle doit terminer une opération de téléchargement en cours avant de pouvoir créer une session à l'aide de ces options.
• "available" signifie que l'implémentation est compatible avec les options demandées sans nécessiter de nouveaux téléchargements.

Pour déclencher le téléchargement du modèle et créer la session du modèle de langage, appelez la fonction LanguageModel.availability() asynchrone. Si la réponse à availability() était 'downloadable', il est recommandé d'écouter la progression du téléchargement. Vous pouvez ainsi informer l'utilisateur si le téléchargement prend du temps.

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

Capacités du modèle

La fonction params() vous informe des paramètres du modèle de langage. L'objet comporte les champs suivants:

• defaultTopK: valeur par défaut de la meilleure K (par défaut: 3).
• maxTopK: valeur top-K maximale (8).
• defaultTemperature: température par défaut (1.0). La valeur de température doit être comprise entre 0.0 et 2.0.
• maxTemperature: température maximale.

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

Créer une session

Une fois que l'API Prompt peut s'exécuter, vous créez une session avec la fonction create(). Vous pouvez inviter le modèle à utiliser les fonctions prompt() ou promptStreaming().

Personnaliser votre session

Chaque session peut être personnalisée avec topK et temperature à l'aide d'un objet d'options facultatif. Les valeurs par défaut de ces paramètres sont renvoyées à partir de 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,
});

L'objet d'options facultatif de la fonction create() prend également un champ signal, qui vous permet de transmettre un AbortSignal pour détruire la session.

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

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

Requêtes initiales

Avec les invites initiales, vous pouvez fournir au modèle de langage un contexte sur les interactions précédentes, par exemple pour permettre à l'utilisateur de reprendre une session stockée après un redémarrage du navigateur.

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. [...]' }
  ]
});

Limite de sessions

Une session de modèle de langage donnée a un nombre maximal de jetons qu'elle peut traiter. Vous pouvez vérifier l'utilisation et la progression vers cette limite à l'aide des propriétés suivantes sur l'objet de session:

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

Persistance de la session

Chaque session suit le contexte de la conversation. Les interactions précédentes sont prises en compte pour les interactions futures jusqu'à ce que la fenêtre de contexte de la session soit remplie.

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

Cloner une session

Pour préserver les ressources, vous pouvez cloner une session existante à l'aide de la fonction clone(). Le contexte de la conversation est réinitialisé, mais l'invite initiale reste intacte. La fonction clone() utilise un objet d'options facultatif avec un champ signal, qui vous permet de transmettre un AbortSignal pour détruire la session clonée.

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

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

Interroger le modèle

Vous pouvez inviter le modèle à utiliser les fonctions prompt() ou promptStreaming().

Sortie sans streaming

Si vous attendez un résultat court, vous pouvez utiliser la fonction prompt(), qui renvoie la réponse une fois qu'elle est disponible.

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

Sortie en streaming

Si vous attendez une réponse plus longue, vous devez utiliser la fonction promptStreaming(), qui vous permet d'afficher des résultats partiels à mesure qu'ils proviennent du modèle. La fonction promptStreaming() renvoie un 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);
  }
}

Arrêter l'exécution d'une requête

prompt() et promptStreaming() acceptent un deuxième paramètre facultatif avec un champ signal, qui vous permet d'arrêter l'exécution des invites.

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

const result = await session.prompt(
  'Write me a poem!',
  { signal: controller.signal }
);

Arrêter une session

Appelez destroy() pour libérer des ressources si vous n'avez plus besoin d'une session. Lorsqu'une session est détruite, elle ne peut plus être utilisée et toute exécution en cours est interrompue. Vous pouvez conserver la session si vous prévoyez d'inviter souvent le modèle, car la création d'une session peut prendre un certain temps.

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

Démo

Pour tester l'API Prompt dans les extensions Chrome, installez l'extension de démonstration. Le code source de l'extension est disponible sur GitHub.

Participer et envoyer des commentaires

Vos commentaires peuvent avoir un impact direct sur la façon dont nous créons et implémentons les futures versions de cette API et de toutes les API d'IA intégrées.

• Pour envoyer des commentaires sur l'implémentation de Chrome, envoyez un rapport de bug ou une demande de fonctionnalité.
• Partagez vos commentaires sur la forme de l'API en commentant un problème existant ou en en créant un dans le dépôt GitHub de l'API Prompt.
• Téléchargez l'exemple d'extension de l'API Prompt sur GitHub.
• Participez à l'élaboration des normes en rejoignant le groupe de la communauté Web Incubator.