Chatbot

Chatbot Lacier : Explication Détaillée du Code et de l'IA

Introduction

Le chatbot Lacier est conçu pour interagir avec les utilisateurs, fournir des informations sur les produits de signalétique et suivre les commandes. Il utilise Flask pour gérer le backend, SQLAlchemy pour la base de données, et OpenAI pour l'intelligence artificielle. De plus, le bot utilise des appels API vers PrestaShop pour accéder aux informations de commande et de client.

Intelligence Artificielle Utilisée

Le modèle d'IA utilisé dans le chatbot est le modèle Llama-3.1-Nemotron-70B-Instruct d'OpenAI, spécifiquement configuré pour fournir des réponses structurées et précises dans le domaine de la signalétique. Ce modèle est un LLM (Large Language Model) capable de comprendre et de générer du texte en fonction de prompts.

---

1. Structure du Code

Fichier Principal : app.py

Importations et Bibliothèques

import subprocess
import xml.etree.ElementTree as ET
import re
import logging
import requests
from flask import Flask, render_template, request, jsonify
from flask_sqlalchemy import SQLAlchemy
import openai
import time
from threading import Thread
from datetime import datetime

Les principales bibliothèques incluent :

• subprocess pour exécuter des commandes en ligne de commande.

• Flask pour le framework web.

• SQLAlchemy pour l'interaction avec la base de données PostgreSQL.

• openai pour l'accès au modèle d'intelligence artificielle.

• Threading et datetime pour la gestion de l'historique des conversations.

Initialisation de Flask et Configuration de la Base de Données

app = Flask(__name__)
app.secret_key = '...'
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://...'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

L'application utilise Flask et SQLAlchemy pour gérer la base de données PostgreSQL qui stocke l'historique des conversations.

---

2. Structure de la Base de Données et Gestion de la Mémoire

Modèle ConversationHistory

class ConversationHistory(db.Model):
    __tablename__ = 'conversation_history'
    id = db.Column(db.Integer, primary_key=True)
    client_uuid = db.Column(db.String(50), nullable=False)
    message_role = db.Column(db.String(10), nullable=False)
    message_text = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

Chaque conversation est stockée dans la base de données avec :

• client_uuid : identifiant unique de chaque utilisateur pour suivre ses conversations.

• message_role : identifie si le message vient de l'utilisateur ou de l'assistant.

• message_text : contenu du message.

• created_at : date et heure de la création du message.

Gestion de la Mémoire

Pour permettre à l'IA de "se souvenir" des échanges récents :

1. Stockage dans la Base de Données : Chaque message est enregistré en base, permettant de retrouver le contexte d'une conversation spécifique.

2. Historique Temporaire : En mémoire, un historique limité de messages est conservé pour chaque utilisateur via le dictionnaire conversation_histories.

MAX_MESSAGES = 6
def trim_conversation_history(history):
    return history[-MAX_MESSAGES:]

1. Nettoyage des Conversations Inactives : Une fonction périodique nettoie les conversations inactives de plus de 30 minutes.

def clean_inactive_conversations():
    while True:
        now = time.time()
        timeout = 1800  # 30 minutes en secondes
        for sender_id in list(conversation_histories.keys()):
            last_activity = conversation_histories[sender_id]["last_activity"]
            if now - last_activity > timeout:
                del conversation_histories[sender_id]
        time.sleep(300)

---

3. Intégration et Fonctionnement de l'IA

API OpenAI

La configuration de l'API OpenAI est effectuée avec la clé API et le modèle nvidia/Llama-3.1-Nemotron-70B-Instruct.

openai.api_key = "votre_clé_api"
openai.api_base = "https://api.deepinfra.com/v1/openai"

Prompt de l'IA et Messages Systèmes

L'IA est guidée par un prompt système (SYSTEM_MESSAGE) qui fournit des instructions spécifiques. Cela garantit que les réponses sont cohérentes et adaptées au contexte de la signalétique.

SYSTEM_MESSAGE = """
You are a signage expert working for a professional company called Lacier. Always respond in a concise and factual manner...
"""

Fonction de Communication avec l'IA

La fonction create_chat_completion envoie l'historique des messages (limité par MAX_MESSAGES) à l'API OpenAI et retourne la réponse générée.

def create_chat_completion(messages):
    chat_completion = openai.ChatCompletion.create(
        model="nvidia/Llama-3.1-Nemotron-70B-Instruct",
        messages=messages,
        temperature=0.2
    )
    return chat_completion.choices[0].message['content']

---

4. Gestion des Images Associées aux Réponses de l'IA

Pour certaines réponses, l'IA peut ajouter des balises [IMAGE:nom_image] dans son texte, correspondant à des mots-clés définis dans le dictionnaire keyword_image_map.

keyword_image_map = {
    "inox": "/static/images/INOX.png",
    ...
}

La fonction extract_images_from_message identifie les balises [IMAGE:nom_image] dans le texte et extrait les URLs des images correspondantes.

def extract_images_from_message(message):
    image_keywords = re.findall(r'\[IMAGE:(.*?)\]', message)
    unique_image_urls = {keyword_image_map.get(keyword) for keyword in image_keywords if keyword in keyword_image_map}
    return list(unique_image_urls)

---

5. Intégration avec PrestaShop

Le chatbot récupère des informations sur les commandes et les clients en utilisant l'API de PrestaShop. Les configurations API pour deux sites sont définies dans API_CONFIGS.

Fonctions d'Appel API

1. fetch_order_by_reference : Récupère les informations d'une commande en utilisant son numéro.

2. fetch_customer_by_id : Récupère les informations d'un client.

3. fetch_order_status_name : Récupère le statut de la commande.

def fetch_order_by_reference(reference):
    for api in API_CONFIGS:
        url = f"{api['api_url_orders']}?filter\\[reference\\]={reference}&display=full"
        command = ['curl', '-X', 'GET', url, '-u', f"{api['api_key']}:"]
        result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
        if result.returncode == 0:
            return result.stdout, api
    return None, None

Parsing XML pour Extraire les Données

Les fonctions parse_order_xml, parse_customer_xml, et parse_order_status_xml extraient les informations pertinentes du XML retourné par PrestaShop.

def parse_order_xml(order_xml):
    root = ET.fromstring(order_xml)
    order_elem = root.find('order')
    order_info = {
        'id': get_text(order_elem, 'id'),
        'reference': get_text(order_elem, 'reference'),
        'total_paid': get_text(order_elem, 'total_paid'),
        ...
    }
    return order_info

---

6. Interface Utilisateur (HTML et JavaScript)

Le fichier HTML chat_ai.html gère l'interface utilisateur avec deux modes :

• Mode IA pour les questions générales.

• Mode Commande pour le suivi des commandes.

Le JavaScript gère l'affichage des messages, le mode de sélection et l'envoi des requêtes à Flask.

Exemple de Fonction JavaScript pour Envoyer un Message

function sendMessage() {
    const message = userInput.value.trim();
    const endpoint = chatMode === 'ia' ? '/ai_chat' : '/chat';
    fetch(endpoint, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ message: message, clientUUID: clientUUID }),
    })
    .then(response => response.json())
    .then(jsonData => {
        addBotMessage(jsonData.reply);
    });
}

---

7. Surveillance et Maintenance

Commandes de Démarrage et Surveillance

Pour exécuter le chatbot en production, gunicorn est utilisé avec nohup pour exécuter le processus en arrière-plan.

nohup gunicorn -w 4 -b unix:/var/www/ChatBotFinal/chatbot_final.sock app:app &

Les services Nginx et Gunicorn peuvent être surveillés avec systemctl pour assurer qu'ils fonctionnent correctement.