Structuration de l’intelligence artificielle par l’ingénierie logicielle : les apports des design patterns à l’intégration des LLM

// Définition d'une interface scellée pour les stratégies d'analyse de conformité.
public sealed interface RegulatoryComplianceStrategy permits GPT4ComplianceStrategy, LocalLegalModelStrategy, KeywordHeuristicComplianceStrategy {
    String analyzeCompliance(String legalText);
}

// Implémentation simulant une analyse avec GPT-4o (appel externe).
public final class GPT4ComplianceStrategy implements RegulatoryComplianceStrategy {
    @Override
    public String analyzeCompliance(String legalText) {
        // Simulation d'un appel externe à GPT-4o pour analyser le texte.
        return "Analyse GPT-4o: ...";
    }
}

// Implémentation simulant une analyse avec un modèle légal open source local.
public final class LocalLegalModelStrategy implements RegulatoryComplianceStrategy {
    @Override
    public String analyzeCompliance(String legalText) {
        // Simulation d'une analyse par un modèle local.
        return "Analyse modèle local: ...";
    }
}

// Implémentation utilisant une approche heuristique basée sur des mots-clés.
public final class KeywordHeuristicComplianceStrategy implements RegulatoryComplianceStrategy {
    @Override
    public String analyzeCompliance(String legalText) {
        // Analyse simple : recherche de mots-clés liés à la conformité.
        if (legalText.contains("RGPD") || legalText.contains("conformité")) {
            return "Analyse heuristique: Critères de conformité détectés.";
        } else {
            return "Analyse heuristique: Aucun indice de conformité détecté.";
        }
    }
}

// Contexte qui utilise la stratégie choisie dynamiquement.
public class ComplianceContext {
    private RegulatoryComplianceStrategy strategy;

    public ComplianceContext(RegulatoryComplianceStrategy strategy) {
        if (strategy == null) {
            throw IllegalStateException("La stratégie est nulle");
        }
        this.strategy = strategy;
    }

    // Permet de modifier la stratégie à la volée.
    public void setStrategy(RegulatoryComplianceStrategy strategy) {
        this.strategy = strategy;
    }

    // Méthode pour analyser la conformité du texte juridique.
    public String analyze(String legalText) {
        return strategy.analyzeCompliance(legalText);
    }
}

// Classe de démonstration pour simuler l'analyse de conformité dans une application de support juridique.
public class RegulatoryComplianceDemo {
    public static void main(String[] args) {
        // Exemple de requête juridique : analyse de la conformité par rapport au RGPD.
        String legalQuery = "L'utilisation des données doit être conforme au RGPD et respecter les droits des utilisateurs.";

        RegulatoryComplianceStrategy strategy = null;

        // Critères simulés : si le texte est sensible (contient "RGPD") ou selon sa longueur.
        boolean isSensitive = legalQuery.contains("RGPD");
        int length = legalQuery.length();

        // Choix de la stratégie en fonction des critères.
        if (isSensitive) {
            // Pour des données sensibles, utiliser le modèle local pour éviter les appels externes.
            strategy = new LocalLegalModelStrategy();
        } else if (length > 100) {
            // Si le texte est très long, utiliser GPT-4 pour une analyse détaillée.
            strategy = new GPT4ComplianceStrategy();
        } else {
            // Sinon, se contenter d'une analyse heuristique.
            strategy = new KeywordHeuristicComplianceStrategy();
        }

        ComplianceContext context = new ComplianceContext(strategy);

        // Affichage du résultat de l'analyse.
        System.out.println(context.analyze(legalQuery));

        // Simulation d'un autre cas d'usage avec un texte différent.
        String anotherQuery = "Vérifier si l'utilisation de ces données respecte les normes internationales sans référence au RGPD.";
        // Ici, on choisit directement l'analyse heuristique.
        context.setStrategy(new KeywordHeuristicComplianceStrategy());
        System.out.println(context.analyze(anotherQuery));
    }
}

// Définition d'une interface scellée pour les événements du cycle de vie du chatbot.
public sealed interface ChatbotEvent permits QueryReceived, InfoRetrieved, ResponseGenerated, ErrorOccurred {
}

// Événement indiquant la réception d'une requête utilisateur.
public record QueryReceived(String query) implements ChatbotEvent {
}

// Événement indiquant la récupération d'informations pertinentes.
public record InfoRetrieved(String info) implements ChatbotEvent {
}

// Événement indiquant la génération d'une réponse.
public record ResponseGenerated(String response) implements ChatbotEvent {
}

// Événement indiquant qu'une erreur est survenue.
public record ErrorOccurred(Exception exception) implements ChatbotEvent {
}

// Interface des observateurs qui réagissent aux événements du chatbot.
public interface ChatbotObserver {
    void update(ChatbotEvent event);
}

// Observateur chargé de la journalisation.
public class LoggerObserver implements ChatbotObserver {
    @Override
    public void update(ChatbotEvent event) {
        switch (event) {
            case QueryReceived qr ->
                System.out.println("[Logger] Requête reçue : " + qr.getQuery());
            case InfoRetrieved ir ->
                System.out.println("[Logger] Informations récupérées : " + ir.getInfo());
            case ResponseGenerated rg ->
                System.out.println("[Logger] Réponse générée : " + rg.getResponse());
            case ErrorOccurred eo ->
                System.out.println("[Logger] Erreur : " + eo.getException().getMessage());
            default -> {}  // Facultatif : gérer les types inattendus
        }
    }
}

// Observateur chargé d'envoyer des données analytiques.
public class AnalyticsObserver implements ChatbotObserver {
    @Override
    public void update(ChatbotEvent event) {
        if (event instanceof ResponseGenerated rg) {
            System.out.println("[Analytics] La réponse générée contient " + rg.getResponse().length() + " caractères.");
        }
    }
}

// Classe gérant le cycle de vie du chatbot et notifiant les observateurs.
public class ChatbotAgent {
    private final List<ChatbotObserver> observers = new ArrayList<>();

    public void addObserver(ChatbotObserver observer) {
        observers.add(observer);
    }

    public void removeObserver(ChatbotObserver observer) {
        observers.remove(observer);
    }

    private void notifyObservers(ChatbotEvent event) {
        observers.forEach(observer -> observer.update(event));
    }

    // Traitement d'une requête utilisateur avec récupération d'infos et génération de réponse.
    public void processQuery(String query) {
        // Notifier la réception de la requête.
        notifyObservers(new QueryReceived(query));

        try {
            // Étape de récupération (RAG) : interroger la base de connaissances.
            var retrievedInfo = retrieveInfo(query);
            notifyObservers(new InfoRetrieved(retrievedInfo));

            // Étape de génération : créer une réponse à partir des informations récupérées.
            var response = generateResponse(retrievedInfo);
            notifyObservers(new ResponseGenerated(response));
        } catch (Exception ex) {
            // En cas d'erreur, notifier les observateurs.
            notifyObservers(new ErrorOccurred(ex));
        }
    }

    // Simulation d'une récupération d'informations (ex. interrogation d'une base de connaissances).
    private String retrieveInfo(String query) throws InterruptedException {
        // Simulation d'un délai de traitement.
        return "Informations pertinentes pour : " + query;
    }

    // Simulation de la génération d'une réponse par un agentic RAG.
    private String generateResponse(String info) throws InterruptedException {
        // Simulation d'un délai de traitement.
        return "Réponse générée à partir de : " + info;
    }
}

// Classe de démonstration du pattern Observer appliqué à un chatbot de support client.
public class ChatbotObserverDemo {
    public static void main(String[] args) {
        ChatbotAgent chatbot = new ChatbotAgent();

        // Ajout des observateurs : Logger et Analytics.
        chatbot.addObserver(new LoggerObserver());
        chatbot.addObserver(new AnalyticsObserver());

        // Traitement d'une requête utilisateur.
        chatbot.processQuery("Comment réinitialiser mon mot de passe ?");
    }
}