Module Chatbot

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-ft5"

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

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}")

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

# 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)

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})