Aller au contenu principal

Sessions de discussion IA

Le module chats.py, qui fait partie de la bibliothèque google.genai, est conçu pour faciliter et gérer les conversations multi-tours (sessions de chat) avec un modèle d'IA générative, tel que Gemini de Google. Il masque les complexités liées à la gestion de l'historique des conversations, à l'envoi de messages et au traitement des réponses, en offrant une interface de plus haut niveau pour la création d'applications d'IA conversationnelle.

Objectif principal​

L'objectif principal de ce module est de permettre aux développeurs de créer et de gérer des sessions de discussion persistantes avec un grand modèle linguistique (LLM). Cela comprend :

  1. Gestion de l'historique de conversation : Il assure automatiquement le suivi des entrées utilisateur et des réponses du modèle, garantissant que chaque tour de conversation ultérieur dispose du contexte nécessaire.
  2. Envoi de messages : Il fournit des méthodes pour envoyer des messages au modèle d'IA au sein d'une session de discussion.
  3. Gestion des réponses : Il gère la récupération et le traitement des réponses du modèle, y compris les réponses en flux continu.
  4. Validation de l'historique : Il intègre une logique pour valider l'intégrité et la structure du contenu de l'historique de conversation, en distinguant un historique « complet » (toutes les interactions) d'un historique « organisé » (tours valides pour le contexte).
  5. Opérations asynchrones : Il offre des interfaces synchrones (Chat) et asynchrones (AsyncChat) pour une intégration flexible dans différentes architectures d'application.

Classes clés et leurs fonctionnalités​

  • _BaseChat : Une classe de base abstraite qui encapsule la logique commune de gestion de l'historique de discussion, y compris :

    • _comprehensive_history : Stocke tous les tours de la discussion, y compris les sorties du modèle potentiellement invalides ou rejetées.
    • _curated_history : Stocke uniquement les tours valides qui sont utilisés comme contexte pour les requêtes ultérieures du modèle. Ceci est crucial pour maintenir des conversations cohérentes.
    • record_history() : Ajoute de nouvelles entrées utilisateur et sorties du modèle aux deux historiques, en validant la sortie du modèle.
    • get_history() : Permet la récupération de l'historique complet ou de l'historique organisé.

  • Chat :

    • Session de discussion synchrone : Représente une session de discussion unique et synchrone avec un modèle d'IA générative.
    • send_message(message, config=None) : Envoie un message utilisateur et renvoie la réponse complète du modèle dans un appel bloquant. L'historique de discussion (organisé) est automatiquement inclus comme contexte.
    • send_message_stream(message, config=None) : Envoie un message utilisateur et fournit la réponse du modèle par morceaux (en flux continu). Ceci est utile pour afficher des réponses partielles au fur et à mesure de leur génération.

  • AsyncChat :

    • Session de discussion asynchrone : Similaire à Chat, mais fournit des méthodes asynchrones (async def) pour des opérations non bloquantes, adaptées aux serveurs web, aux interfaces utilisateur ou à d'autres frameworks asynchrones.
    • await send_message(message, config=None) : Version asynchrone de send_message.
    • async for chunk in await send_message_stream(message, config=None) : Version asynchrone de send_message_stream.

  • Chats :

    • Fabrique de sessions de discussion synchrone : Une classe utilitaire pour créer de nouvelles instances de Chat. Elle prend un objet Models sous-jacent (qui gère les appels d'API réels vers le modèle génératif).
    • create(model, config=None, history=None) : Instancie et renvoie un nouvel objet Chat, initialisé avec un modèle spécifié et un historique initial facultatif.

  • AsyncChats :

    • Fabrique de sessions de discussion asynchrones : Similaire à Chats, mais crée des instances de AsyncChat, en prenant un objet AsyncModels.
    • create(model, config=None, history=None) : Instancie et renvoie un nouvel objet AsyncChat.

Cas d'utilisation​

Ce module est fondamental pour toute application qui nécessite des conversations interactives et multi-tours avec un modèle d'IA générative.

  1. Création d'agents conversationnels IA / de chatbots :

    • Bots de support client : Répondent automatiquement aux questions courantes, escaladent vers des agents humains si nécessaire, et maintiennent le contexte des requêtes d'un utilisateur.
    • Assistants virtuels : Fournissent des informations, effectuent des tâches et engagent une conversation libre.
    • Narration interactive / Jeux : Créent des récits dynamiques où les réponses de l'IA évoluent en fonction des entrées du joueur.

  2. Génération de contenu avec contexte :

    • Assistants d'écriture créative : Aident les rédacteurs en générant du texte, en proposant des idées ou en affinant le contenu, en se souvenant des tours et des invites précédents.
    • Outils de génération de code : Aident les développeurs en générant des extraits de code ou en expliquant des concepts de manière conversationnelle, en gardant une trace du contexte du projet.

  3. Outils éducatifs :

    • Tuteurs personnalisés : Fournissent des explications et répondent aux questions dans un dialogue continu, s'adaptant au rythme d'apprentissage de l'étudiant et aux interactions précédentes.
    • Applications d'apprentissage des langues : Engagent les utilisateurs dans une pratique conversationnelle, corrigeant la grammaire ou suggérant du vocabulaire.

  4. Exploration et analyse de données (interface conversationnelle) :

    • Permettent aux utilisateurs d'interroger des données ou de générer des rapports via une conversation en langage naturel, où les questions de suivi exploitent le contexte des requêtes précédentes.

  5. Environnements de développement interactifs :

    • S'intègrent directement dans les IDE ou les outils en ligne de commande pour fournir une assistance IA qui comprend le contexte de codage en cours.

Exemple d'utilisation (issu des commentaires)​

Discussion synchrone :

import google.generativeai as genai

# Supposons que 'client' est un client genai initialisé
client = genai.GenerativeModel('gemini-pro') # Espace réservé pour l'initialisation réelle du client
chat = client.chats.create(model='gemini-pro') # Utilisation de client.chats.create
response = chat.send_message('tell me a story')
print(response.text)

# Réponse en flux continu
for chunk in chat.send_message_stream('continue the story'):
  print(chunk.text, end='')

Discussion asynchrone :

import google.generativeai as genai

# Supposons que 'client.aio' est un client asynchrone initialisé
async_client = genai.AsyncGenerativeModel('gemini-pro') # Espace réservé pour l'initialisation réelle du client
chat = async_client.aio.chats.create(model='gemini-pro') # Utilisation de client.aio.chats.create
response = await chat.send_message('tell me a story')
print(response.text)

# Réponse en flux continu de manière asynchrone
async for chunk in await chat.send_message_stream('continue the story'):
  print(chunk.text, end='')

Essentiellement, chats.py fournit les blocs de construction fondamentaux pour créer des expériences conversationnelles intelligentes, interactives et avec état, alimentées par les modèles d'IA générative de Google.