Passer au contenu principal

​
Aperçu

Le module Chatbot fournit une interface de questions-réponses qui répond aux questions des utilisateurs en utilisant les documents stockés dans un workspace dédié. Il combine l’IA conversationnelle avec le RAG (Retrieval-Augmented Generation) pour fournir des réponses précises basées sur les documents.
Vous pouvez également envoyer du contexte au chatbot en utilisant un prompt côté backend. Par exemple, en ajoutant des variables provenant de votre datalake afin d’ajouter du contexte sur l’utilisateur qui utilise le chatbot.
Cas d’usage : Construire un chatbot qui répond aux questions basées sur la base de connaissances de votre entreprise (politiques, FAQ, documentation produit, etc.)
Note: Les exemples de cette documentation utilisent un serveur web Flask en local. Soyez vigilant si vous souhaitez mettre en production. Cet exemple a été effectué avec un frontend HTML qui envoi au backend les variables.

​
Fonctionnement

  1. L’utilisateur envoie un message
  2. Le système construit le contexte à partir de l’historique de conversation
  3. La requête est envoyée à l’API Document Search ciblant le workspace du chatbot
  4. Le LLM génère une réponse basée sur le contenu pertinent des documents
  5. La conversation est stockée pour le contexte des futurs messages

​
Endpoints API Utilisés

EndpointObjectif
POST /chat/document-searchInterroger les documents et générer des réponses

​
Implémentation Étape par Étape

​
Étape 1 : Initialiser le Service

import requests
from typing import Dict, Any, Optional, List

class ChatbotService:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        self.conversations = {}  # Stockage en mémoire des conversations

        # Configuration
        self.document_search_url = "https://paradigm.lighton.ai/api/v2/chat/document-search"
        self.workspace_id = 250  # Votre ID de workspace chatbot
        self.model = "alfred-4.2"

​
Étape 2 : Construire le Contexte de Conversation

def _build_context(
    self,
    message: str,
    conversation_id: Optional[str],
    system_prompt: Optional[str]
) -> str:
    """Construire le contexte de requête depuis l'historique de conversation."""
    context = ""

    # Ajouter le prompt système si fourni
    if system_prompt:
        context += f"{system_prompt}\n\n"

    # Ajouter l'historique de conversation si existant
    if conversation_id and conversation_id in self.conversations:
        context += "Conversation précédente:\n"
        for msg in self.conversations[conversation_id]:
            role = msg["role"].capitalize()
            content = msg["content"]
            context += f"{role}: {content}\n"
        context += "\n"

    return context

​
Étape 3 : Envoyer un Message

def chat(
    self,
    message: str,
    conversation_id: Optional[str] = None,
    system_prompt: Optional[str] = None,
    temperature: float = 0.7
) -> Dict[str, Any]:
    """
    Envoyer un message et obtenir une réponse via document search.

    Args:
        message: Question de l'utilisateur
        conversation_id: ID optionnel pour la continuité de conversation
        system_prompt: Instructions optionnelles pour l'assistant
        temperature: Créativité de la réponse (0.0-1.0)

    Returns:
        Réponse avec answer et conversation_id
    """
    # Construire le contexte depuis l'historique
    context = self._build_context(message, conversation_id, system_prompt)

    # Construire la requête
    query = f"{context}Question actuelle: {message}"

    # Préparer le payload pour Document Search
    payload = {
        "model": self.model,
        "query": query,
        "workspace_ids": [self.workspace_id],
        "company_scope": False,
        "private_scope": False,
        "tool": "DocumentSearch"
    }

    # Appel API
    response = requests.post(
        self.document_search_url,
        headers=self.headers,
        json=payload,
        timeout=150
    )

    if response.status_code == 200:
        data = response.json()
        assistant_message = data.get("answer", "")

        # Générer un ID de conversation si non fourni
        if not conversation_id:
            import uuid
            conversation_id = str(uuid.uuid4())
            self.conversations[conversation_id] = []

        # Stocker l'historique de conversation
        if conversation_id in self.conversations:
            self.conversations[conversation_id].append({
                "role": "user",
                "content": message
            })
            self.conversations[conversation_id].append({
                "role": "assistant",
                "content": assistant_message
            })

        return {
            'response': assistant_message,
            'conversation_id': conversation_id,
            'status': 'success',
            'workspace_id': self.workspace_id
        }
    else:
        raise Exception(f"Document search échoué: {response.text}")

​
Étape 4 : Gérer l’Historique de Conversation

def get_conversation_history(self, conversation_id: str) -> List[Dict[str, str]]:
    """Obtenir l'historique de conversation pour un ID donné."""
    if conversation_id not in self.conversations:
        raise ValueError(f"Conversation {conversation_id} non trouvée")
    return self.conversations[conversation_id]

def clear_conversation(self, conversation_id: str) -> bool:
    """Effacer l'historique de conversation."""
    if conversation_id in self.conversations:
        del self.conversations[conversation_id]
        return True
    return False

​
Exemple d’Utilisation Complet

# Initialiser le chatbot
chatbot = ChatbotService(api_key="votre-cle-api")

# Prompt système pour le chatbot
system_prompt = """Tu es un assistant support IT serviable.
Réponds aux questions basées sur la documentation IT de l'entreprise.
Sois concis et fournis des instructions étape par étape quand c'est pertinent."""

# Premier message - démarre une nouvelle conversation
result = chatbot.chat(
    message="Comment réinitialiser mon mot de passe ?",
    system_prompt=system_prompt
)

print(f"Assistant: {result['response']}")
conversation_id = result['conversation_id']

# Message de suivi - utilise le contexte de conversation
result = chatbot.chat(
    message="Et si je ne reçois pas l'email de réinitialisation ?",
    conversation_id=conversation_id,
    system_prompt=system_prompt
)

print(f"Assistant: {result['response']}")

# Obtenir l'historique complet
history = chatbot.get_conversation_history(conversation_id)
for msg in history:
    print(f"{msg['role'].upper()}: {msg['content']}")

# Effacer la conversation quand terminé
chatbot.clear_conversation(conversation_id)

​
Intégration Route Flask

from flask import Blueprint, request, jsonify

chatbot_bp = Blueprint('chatbot', __name__)
chatbot_service = None

def init_chatbot_service(api_key: str):
    global chatbot_service
    chatbot_service = ChatbotService(api_key)

@chatbot_bp.route('/chat', methods=['POST'])
def chat():
    """Endpoint de chat."""
    data = request.json

    message = data.get('message')
    conversation_id = data.get('conversation_id')
    system_prompt = data.get('system_prompt')

    if not message:
        return jsonify({'error': 'Le message est requis'}), 400

    try:
        result = chatbot_service.chat(
            message=message,
            conversation_id=conversation_id,
            system_prompt=system_prompt
        )
        return jsonify(result)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@chatbot_bp.route('/conversation/<conversation_id>', methods=['GET'])
def get_history(conversation_id):
    """Obtenir l'historique de conversation."""
    try:
        history = chatbot_service.get_conversation_history(conversation_id)
        return jsonify({'history': history})
    except ValueError as e:
        return jsonify({'error': str(e)}), 404

@chatbot_bp.route('/conversation/<conversation_id>', methods=['DELETE'])
def clear_history(conversation_id):
    """Effacer l'historique de conversation."""
    result = chatbot_service.clear_conversation(conversation_id)
    return jsonify({'cleared': result})

​
Prérequis

Avant d’utiliser ce module :
  1. Créer un workspace pour vos documents de chatbot
  2. Uploader les documents dans le workspace via l’API Upload Session
  3. Attendre l’embedding - les documents doivent être entièrement indexés avant interrogation
  4. Noter le workspace_id - vous en aurez besoin pour la configuration du service

​
Configuration

ParamètreDescriptionDéfaut
workspace_idID du workspace contenant les documents du chatbotRequis
modelModèle LLM à utiliseralfred-4.2
timeoutTimeout de requête API en secondes150

​
Bonnes Pratiques

  1. Utiliser des prompts système pour définir la personnalité et le comportement du chatbot
  2. Stocker les conversations de façon persistante en production (base de données, Redis, etc.)
  3. Limiter l’historique de conversation pour éviter les limites de tokens (garder les 10-20 derniers messages)
  4. Gérer les erreurs gracieusement avec des messages user-friendly
  5. Garder les documents à jour dans le workspace pour des réponses précises