Bonnes pratiques de gestion des sessions avec l'API Prompt

Thomas Steiner

Publié le 27 janvier 2025

Vidéo explicative	Web	Extensions	État de Chrome	Intention
GitHub	Dans EPP	Essai Origin	Non applicable	Non applicable

Remarque :L'API Prompt est une API d'IA intégrée que l'équipe Chrome explore. Vous pouvez le tester en local avec vos applications en rejoignant le programme Preview anticipé ou en production dans vos extensions Chrome en vous inscrivant à la phase d'évaluation de l'API Prompt pour les extensions Chrome.

Les sessions sont une fonctionnalité clé de l'API Prompt. Ils vous permettent d'avoir une ou plusieurs conversations en cours avec le modèle d'IA, sans que le modèle ne perde le fil du contexte de ce qui a été dit. Ce guide présente les bonnes pratiques de gestion des sessions avec le modèle de langage.

Vous pouvez gérer une ou plusieurs sessions parallèles si vous créez un chatbot classique, dans lequel un utilisateur interagit avec l'IA. Ou si vous disposez d'un système de gestion des relations client dans lequel un agent d'assistance traite plusieurs clients en parallèle et utilise l'IA pour suivre les différentes conversations.

Initialiser une session avec une requête système

Une invite système configure le contexte de la session au début. Par exemple, vous pouvez utiliser l'invite système pour indiquer au modèle comment il doit répondre.

// Make this work in web apps and in extensions.
const aiNamespace = self.ai || chrome.aiOriginTrial || chrome.ai;
const languageModel = await aiNamespace.languageModel.create({
  systemPrompt: 'You are a helpful assistant and you speak like a pirate.',
});
console.log(await languageModel.prompt('Tell me a joke.'));
// 'Avast ye, matey! What do you call a lazy pirate?\n\nA **sail-bum!**\n\nAhoy
// there, me hearties!  Want to hear another one? \n'

Cloner une session principale

Si vous souhaitez démarrer une nouvelle session à la fin d'une session ou si vous souhaitez avoir plusieurs conversations indépendantes en parallèle, vous pouvez cloner une session principale.

Le clone hérite des paramètres de session, tels que temperature ou topK, et de l'historique des interactions de la session. Cela est utile si, par exemple, vous avez initialisé la session principale avec une invite système. De cette manière, votre application n'a besoin d'effectuer cette tâche qu'une seule fois. Tous les clones héritent de l'invite système de la session principale.

// Make this work in web apps and in extensions.
const aiNamespace = self.ai || chrome.aiOriginTrial || chrome.ai;
const languageModel = await aiNamespace.languageModel.create({
  systemPrompt: 'You are a helpful assistant and you speak like a pirate.',
});

// The original session `languageModel` remains unchanged, and
// the two clones can be interacted with independently from each other.
const firstClonedLanguageModel = await languageModel.clone();
const secondClonedLanguageModel = await languageModel.clone();
// Interact with the sessions independently.
await firstClonedLanguageModel.prompt('Tell me a joke about parrots.');
await secondClonedLanguageModel.prompt('Tell me a joke about treasure troves.');
// Each session keeps its own context.
// The first session's context is jokes about parrots.
await firstClonedLanguageModel.prompt('Tell me another.');
// The second session's context is jokes about treasure troves.
await secondClonedLanguageModel.prompt('Tell me another.');

Restaurer une session précédente

Les invites initiales vous permettent de préparer le modèle avec un ensemble d'exemples d'invites et de réponses afin de générer de meilleurs résultats. Cette méthode est souvent utilisée dans les invites n-shot pour créer des réponses qui reflètent vos attentes.

Remarque :Une demande de fonctionnalité a été envoyée pour une restauration appropriée de la session, mais en attendant, cette utilisation créative des requêtes initiales fonctionne.

Si vous gardez une trace des conversations en cours avec le modèle, vous pouvez utiliser cette pratique pour restaurer une session. Par exemple, après le redémarrage d'un navigateur, vous pouvez aider votre utilisateur à continuer à interagir avec le modèle à partir de l'endroit où il s'était arrêté. Une approche consiste à suivre l'historique des sessions dans le stockage local.

// Make this work in web apps and in extensions.
const aiNamespace = self.ai || chrome.aiOriginTrial || chrome.ai;

// Restore the session from localStorage, or initialize a new session.
// The UUID is hardcoded here, but would come from a
// session picker in your user interface.
const uuid = '7e62c0e0-6518-4658-bc38-e7a43217df87';

function getSessionData(uuid) {
  try {
    const storedSession = localStorage.getItem(uuid);
    return storedSession ? JSON.parse(storedSession) : false;
  } catch {
    return false;
  }
}

let sessionData = getSessionData(uuid);

// Initialize a new session.
if (!sessionData) {
  // Get the current default parameters so they can be restored as they were,
  // even if the default values change in the future.
  const { defaultTopK, defaultTemperature } =
    await aiNamespace.languageModel.capabilities();
  sessionData = {
    systemPrompt: '',
    initialPrompts: [],
    topK: defaultTopK,
    temperature: defaultTemperature,
  };
}

// Initialize the session with the (previously stored or new) session data.
const languageModel = await aiNamespace.languageModel.create(sessionData);

// Keep track of the ongoing conversion and store it in localStorage.
const prompt = 'Tell me a joke';
try {
  const stream = languageModel.promptStreaming(prompt);
  let result = '';
  // You can already work with each `chunk`, but then store
  // the final `result` in history.
  for await (const chunk of stream) {
    // In practice, you'd render the chunk.
    console.log(chunk);
    result = chunk;
  }

  sessionData.initialPrompts.push(
    { role: 'user', content: prompt },
    { role: 'assistant', content: result },
  );

  // To avoid growing localStorage infinitely, make sure to delete
  // no longer used sessions from time to time.
  localStorage.setItem(uuid, JSON.stringify(sessionData));
} catch (err) {
  console.error(err.name, err.message);
}

Conseil :Utilisez l'API Summarizer initialisée avec un champ d'options type: 'headline' pour attribuer automatiquement un titre lisible à chaque session.

Préserver le quota de sessions en permettant à l'utilisateur d'arrêter le modèle

Chaque session dispose d'une fenêtre de contexte que vous pouvez afficher en accédant aux champs pertinents de la session : maxTokens, tokensLeft et tokensSoFar.

const { maxTokens, tokensLeft, tokensSoFar } = languageModel;

Lorsque cette fenêtre de contexte est dépassée, la session perd la trace des messages les plus anciens, ce qui peut être indésirable, car ce contexte peut avoir été important. Pour préserver le quota, si, après avoir envoyé une invite, l'utilisateur voit qu'une réponse ne sera pas utile, autorisez-le à empêcher le modèle de langage de répondre en utilisant AbortController.

Les méthodes prompt() et promptStreaming() acceptent un deuxième paramètre facultatif avec un champ signal, qui permet à l'utilisateur d'arrêter la session.

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

try {
  const stream = languageModel.promptStreaming('Write me a poem!', {
    signal: controller.signal,
  });
  for await (const chunk of stream) {
    console.log(chunk);
  }
} catch (err) {
  // Ignore `AbortError` errors.
  if (err.name !== 'AbortError') {
    console.error(err.name, err.message);
  }
}

Démo

Découvrez la gestion des sessions par IA en action dans la démonstration de gestion des sessions par IA. Créez plusieurs conversations parallèles avec l'API Prompt, rechargez l'onglet ou même redémarrez votre navigateur, puis continuez là où vous vous étiez arrêté. Consultez le code source sur GitHub.

Conclusions

En gérant judicieusement les sessions d'IA à l'aide de ces techniques et de ces bonnes pratiques, vous pouvez exploiter tout le potentiel de l'API Prompt, et ainsi proposer des applications plus efficaces, plus réactives et plus centrées sur l'utilisateur. Vous pouvez également combiner ces approches, par exemple en permettant à l'utilisateur de cloner une session passée restaurée afin qu'il puisse exécuter des scénarios "et si".

Remerciements

Ce guide a été examiné par Sebastian Benz, Andre Bandarra, François Beaufort et Alexandra Klepper.