Cette page a été traduite par l'API Cloud Translation.

Bonnes pratiques de gestion des sessions avec l'API Prompt

Thomas Steiner

Publié le : 27 janvier 2025

Explication	Web	Extensions	État de Chrome	Intent
GitHub	Dans l'Origin Trial	Chrome 138	Afficher	Intention de tester

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

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

Initialiser des sessions avec une requête initiale

Une requête initiale définit le contexte de la session au début. Par exemple, vous pouvez utiliser la requête initiale pour indiquer au modèle comment il doit répondre.

const languageModel = await LanguageModel.create({
  initialPrompts: [{
    role: 'system',
    content: '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 après 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 peut être utile si, par exemple, vous avez initialisé la session principale avec une requête initiale. Ainsi, votre application n'a besoin d'effectuer cette tâche qu'une seule fois : tous les clones héritent de l'invite initiale de la session principale.

const languageModel = await LanguageModel.create({
  initialPrompts: [{
    role: 'system',
    content: '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 passée

Les requêtes initiales vous permettent d'amorcer le modèle avec un ensemble d'exemples de requêtes et de réponses afin de générer de meilleurs résultats. Cette méthode est souvent utilisée dans le prompting n-shot pour créer des réponses qui correspondent à vos attentes.

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 là où il s'était arrêté. Une approche consiste à suivre l'historique des sessions dans le stockage local.

// 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 LanguageModel.params();
  sessionData = {
    initialPrompts: [],
    topK: defaultTopK,
    temperature: defaultTemperature,
  };
}

// Initialize the session with the (previously stored or new) session data.
const languageModel = await 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);
}

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 consulter en accédant aux champs inputQuota et inputUsage de la session.

const { inputQuota, inputUsage } = languageModel;
const inputQuotaLeft = inputQuota - inputUsage;

Lorsque cette fenêtre de contexte est dépassée, la session perd la trace des messages les plus anciens. Cela peut entraîner des résultats moins pertinents si le contexte était important. Pour préserver le quota, si un utilisateur estime que la réponse du modèle n'est pas utile, autorisez-le à mettre fin à la session avec AbortController.

Les méthodes prompt() et promptStreaming() acceptent un deuxième paramètre facultatif avec un champ signal, pour permettre à 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);
  }
}

Supprimer les sessions inutilisées

Chaque session consomme de la mémoire. Si vous avez lancé plusieurs sessions volumineuses, cela peut devenir problématique. Supprimez les sessions inutilisées pour augmenter la disponibilité des ressources.

Démo

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

Exploiter tout le potentiel de l'API Prompt

En gérant soigneusement les sessions d'IA à l'aide de ces techniques et bonnes pratiques, vous pouvez exploiter tout le potentiel de l'API Prompt et proposer des applications plus efficaces, réactives et axé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.