Bonnes pratiques pour la gestion des sessions d'IA avec l'API Prompt

Thomas Steiner

Publié le 27 janvier 2025

L'API Prompt est l'une des API d'IA intégrées 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 l'une des principales fonctionnalités 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.

Les cas d'utilisation de la gestion des sessions pour une ou plusieurs sessions parallèles incluent, par exemple, les chatbots classiques où un utilisateur interagit avec une IA, ou les systèmes de gestion des relations client où un agent du service client gère plusieurs clients en parallèle et utilise l'IA pour suivre les différentes conversations.

Initialiser une session avec une requête système

Le premier concept à connaître est l'invite système. Il configure le contexte global d'une 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 avez une application dans laquelle vous souhaitez en démarrer une nouvelle à la fin d'une session ou si vous souhaitez avoir des conversations indépendantes dans différentes sessions en parallèle, vous pouvez utiliser le concept de clonage d'une session principale. Le clone hérite des paramètres de session tels que temperature ou topK de l'original, ainsi que de l'historique potentiel des interactions de session. Cette opération est utile, par exemple, si vous avez initialisé la session principale avec une invite système. De cette façon, votre application n'a besoin d'effectuer cette tâche qu'une seule fois, et tous les clones hériteront 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

Le troisième concept à apprendre est celui des requêtes initiales. Son objectif initial est de l'utiliser pour l'invite n, c'est-à-dire pour amorcer le modèle avec un ensemble d'n exemples d'invites et de réponses, afin que ses réponses aux invites réelles soient plus précises. Si vous suivez les conversations en cours avec le modèle, vous pouvez "abuser" du concept d'invites initiales pour restaurer une session, par exemple après un redémarrage du navigateur, afin que l'utilisateur puisse continuer avec le modèle là où il s'était arrêté. L'extrait de code suivant montre comment procéder, en supposant que vous suiviez l'historique des sessions dans localStorage.

Remarque :Une fonctionnalité a été demandée pour la restauration appropriée des sessions, mais en attendant, cette utilisation abusive créative de la fonctionnalité d'invite à n coups fonctionne.

// 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 session en permettant à l'utilisateur d'arrêter le modèle lorsque sa réponse n'est pas utile

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'empêcher la session de répondre.

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". Nous vous souhaitons une excellente lecture !

Remerciements

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