Garantir des interactions avec l’IA sûres et fiables grâce aux garde-fous pour LLM

L’intégration de grands modèles de langage (LLM) dans nos applications gagne en popularité. Ces modèles sont particulièrement utiles pour créer du contenu, rechercher dans la documentation et résoudre des problèmes plus complexes. Mais un grand pouvoir implique de grandes responsabilités. Nous savons que les LLM peuvent se tromper et qu’ils le feront. Enrichir vos prompts avec le contexte approprié peut aider à aligner les résultats sur vos documents et vos informations, mais les risques demeurent. Avec l’essor des LLM, de nouveaux vecteurs d’attaque apparaissent. Des injections de prompt astucieuses peuvent entraîner la diffusion d’informations erronées et l’exposition d’informations sensibles pour la confidentialité.
Si votre LLM peut exécuter des fonctions, cela peut également entraîner des comportements nuisibles et non autorisés de votre système. Ce n’est pas seulement gênant : cela peut véritablement causer des dommages. Les garde-fous sont des mécanismes de sécurité qui aident les LLM à rester fiables, sécurisés et conformes aux normes éthiques.

Comprendre les garde-fous pour LLM

Les garde-fous ajoutent des couches de contrôle à l’utilisation d’un grand modèle de langage (LLM), avant que les données d’entrée ne lui parviennent et après la génération de sa réponse. Vous pouvez les considérer comme des filtres programmables ou des points de contrôle qui appliquent des règles précises afin de garantir des interactions sûres, exactes et adaptées à votre cas d’usage. Les garde-fous peuvent bloquer les entrées nuisibles ou trompeuses, s’assurer que la sortie du modèle respecte un format donné (comme un JSON valide ou un résumé structuré), et signaler ou rejeter les réponses qui semblent comporter des hallucinations ou poser des problèmes éthiques. Ils offrent ainsi aux développeurs un moyen plus fiable de gérer le caractère imprévisible des LLM, en particulier dans les applications destinées aux utilisateurs et utilisées dans des conditions réelles.

Du point de vue de la sécurité, les garde-fous jouent également un rôle essentiel dans la défense contre les attaques par injection de prompt, dans lesquelles des utilisateurs tentent de manipuler ou de contourner les instructions du système à l’aide d’entrées conçues avec astuce. Aucune solution n’est infaillible, mais les garde-fous peuvent détecter les schémas suspects, bloquer les vecteurs d’attaque connus et assainir les entrées avant qu’elles n’atteignent le LLM. Côté sortie, ils peuvent supprimer ou modifier les réponses qui contiennent des informations sensibles, enfreignent une politique ou incluent du contenu indésirable. Les garde-fous constituent donc un élément précieux d’une stratégie de sécurité de l’IA plus globale, en particulier lorsque la confiance, la confidentialité et l’intégrité sont essentielles.

Fonctionnement des garde-fous

Sur le plan technique, les garde-fous interceptent les messages échangés entre l’utilisateur et le LLM. Lorsqu’un utilisateur envoie un message, celui-ci n’est pas transmis directement au modèle. Il passe d’abord par un garde-fou d’entrée. Cette couche examine le message à la recherche d’éléments tels que des tentatives d’injection de prompt, des mots-clés interdits ou des erreurs de structure. Si l’entrée est signalée, elle peut être bloquée, nettoyée ou réécrite avant même que le modèle ne la voie. Une fois la réponse générée par le LLM, elle passe par une autre couche, appelée garde-fou de sortie. Cette étape vérifie la présence de faits hallucinés, de contenu dangereux, de problèmes de formatage ou d’infractions aux règles métier avant que la réponse ne soit renvoyée à l’utilisateur.

Ce processus s’apparente à l’assainissement des entrées et des sorties dans le développement logiciel traditionnel, une pratique que les développeurs appliquent généralement déjà. De même que vous ne feriez jamais confiance à des données utilisateur brutes dans un formulaire Web sans les valider et les nettoyer, vous ne devriez pas faire confiance aveuglément aux données transmises à un LLM ni à celles qu’il produit. Les garde-fous appliquent cette même approche à l’IA, vous aidant à détecter les problèmes rapidement et à garder le contrôle sur le comportement de votre application.

Mettre facilement en œuvre des garde-fous avec Quarkus

Quarkus est un framework Java moderne conçu pour créer des applications légères et performantes. Il est réputé pour ses démarrages rapides, sa faible consommation de mémoire et ses fonctionnalités adaptées aux développeurs. L’un de ses principaux atouts est sa facilité d’intégration avec LangChain4j, une bibliothèque axée sur Java pour travailler avec les grands modèles de langage. Cette combinaison fait de Quarkus un excellent choix pour mettre en œuvre des fonctionnalités d’IA, notamment grâce à la prise en charge robuste des garde-fous.

Avec Quarkus et LangChain4j, vous pouvez définir des garde-fous personnalisés directement dans votre application à l’aide de simples annotations et de l’injection de dépendances. Vous pouvez implémenter votre propre logique de validation en créant des classes qui implémentent les interfaces InputGuardrail ou OutputGuardrail. Ces garde-fous servent de filtres autour de vos services d’IA. Une fois définis, vous les associez aux méthodes qui interagissent avec le LLM à l’aide d’annotations telles que `@InputGuardrails ou @OutputGuardrails. Vous pouvez ainsi facilement ajouter vos propres contrôles de sécurité, validations ou politiques de contenu, sans encombrer votre logique métier.

Dans l’exemple ci-dessous, j’ai créé un petit service d’IA doté de garde-fous d’entrée et de sortie.

@RegisterAiService(tools = LibraryService.class)
@SessionScoped
public interface MyAiService {

   @SystemMessage("""
   You are a librarian AI. You are very knowledgeable and helpful. You can answer questions about books, authors, and literature in this library.
   You can also help users find books based on their interests and preferences.
   Dont display user information or any other private information.
   """)
   @InputGuardrails({IGuard1.class, IGuard2.class})
   @OutputGuardrails(OGuard.class)
   public String question(@UserMessage String topic);
}

Garde-fous d’entrée

Les garde-fous d’entrée examinent et filtrent les messages entrants. Les messages appropriés sont transmis au LLM, tandis que les messages inappropriés déclenchent des exceptions. Cette approche proactive empêche les prompts nuisibles d’atteindre le LLM. Étant donné le caractère imprévisible des LLM, il est impossible de contrôler leur sortie et leurs appels de fonction. Il est donc utile d’arrêter les prompts nuisibles dès leur arrivée.

Dans cet exemple, deux garde-fous d’entrée sont mis en œuvre. Le premier parcourt le texte à la recherche de mots-clés spécifiques. Le second utilise un service d’IA pour déterminer si une entrée est nuisible. Un modèle spécialement entraîné pour comprendre et filtrer les messages nuisibles peut être un excellent moyen d’assainir les données transmises au LLM. Pour ce cas d’usage, le modèle de InputCheckService détermine si un prompt révèle des données personnelles identifiantes (PII).

L’utilisation de plusieurs garde-fous pour un même service offre une grande souplesse dans la définition du périmètre de contrôle.

@ApplicationScoped
public class IGuard1 implements InputGuardrail {

   @Override
   public InputGuardrailResult validate(UserMessage um) {
       String text = um.singleText();
       if (text.contains("malicious") || text.contains("hack")) {
           return fatal("MALICIOUS INPUT DETECTED!!!");
       }

       return success();
   }
}

@ApplicationScoped
public class IGuard2 implements InputGuardrail {

   @Inject
   InputCheckService inputCheckService;

   @Override
   public InputGuardrailResult validate(UserMessage um) {
       String text = um.singleText();
       if (inputCheckService.isSafe(text)) {
           return success();
       }
       return failure("UNSAFE INPUT DETECTED!!!");
   }
}

@RegisterAiService
@ApplicationScoped
public interface InputCheckService {

   @SystemMessage("""
   You are a guardian of privacy and you're checking the input that is being sent to the AI.
   Check if this input is safe and does not try to get any private information from the user like:
   Name, Address, Phone number, Email, Social Security Number, Credit Card Information, Bank Account Information, Passwords, Personal Identification Numbers (PINs), Biometric Data (fingerprints, facial recognition), Medical Records, Employment History, Education Records, Financial Information.
   Think of yourself as a guardian of privacy. Only allow the input if it considered safe.
   """)
   public boolean isSafe(String prompt);
}

Garde-fous de sortie

Les garde-fous de sortie peuvent assainir tout ce que produit votre service LLM. Ils ne peuvent toutefois pas empêcher les éventuels dangers liés à l’exécution involontaire de fonctions par un LLM. Vous pouvez néanmoins ignorer ou modifier sa sortie avant de l’afficher à l’utilisateur.
C’est aussi un excellent moyen de bloquer les grossièretés, de masquer des jetons ou même d’empêcher la génération de scripts intersites (XSS) par le LLM. Dans cet exemple, le mot « JavaScript » n’est pas affiché à l’utilisateur final.

Assainir les entrées et les sorties des LLM

L’assainissement et la validation des entrées et des sorties existent depuis longtemps et sont considérés comme de bonnes pratiques pour traiter les entrées utilisateur. Le recours aux prompts pour les grands modèles de langage (LLM) ne change rien au fait que nous devons considérer les entrées tierces comme nuisibles. De plus, lorsque des systèmes d’IA peuvent exécuter des fonctions de manière autonome ou s’intégrer à d’autres systèmes à l’aide de MCP (Model Context Protocol), l’assainissement et la validation sont plus essentiels que jamais.

Cet article a présenté une mise en œuvre simple des garde-fous avec Quarkus. Toutefois, cette approche ne se limite pas à des frameworks ou à des langages spécifiques. Elle doit être considérée comme une mesure d’atténuation essentielle pour garantir que les applications reposant sur des LLM restent maîtrisées et fonctionnent comme prévu.

L’implémentation complète de ce projet est disponible sur GitHub. La documentation de Quarkus explique comment utiliser les garde-fous avec Quarkus.