Sichere und zuverlässige KI-Interaktionen mit LLM-Guardrails gewährleisten

Die Integration großer Sprachmodelle (LLMs) in unsere Anwendungen wird immer beliebter. Diese Modelle sind äußerst nützlich, um Inhalte zu erstellen, Dokumentationen zu durchsuchen und komplexere Probleme zu lösen. Doch mit großer Leistungsfähigkeit geht auch große Verantwortung einher. Wir wissen, dass LLMs Fehler machen können und werden. Auch wenn der passende Kontext in Ihren Prompts dazu beitragen kann, die Ergebnisse an Ihren Dokumenten und Informationen auszurichten, bleiben Risiken bestehen. Mit dem Aufstieg der LLMs entstehen neue Angriffsvektoren. Raffinierte Prompt-Injections können zu Fehlinformationen führen und datenschutzrelevante Informationen preisgeben.
Wenn Ihr LLM Funktionen ausführen kann, kann dies auch zu schädlichem und unbefugtem Verhalten Ihres Systems führen. Das ist nicht nur unangenehm, sondern kann tatsächlich großen Schaden anrichten. Guardrails sind Sicherheitsmechanismen, die LLMs zuverlässig, sicher und an ethischen Standards ausgerichtet halten.

LLM-Guardrails verstehen

Guardrails schaffen zusätzliche Kontrollschichten für den Einsatz eines Large Language Models (LLM) – sowohl bevor die Eingabe das Modell erreicht als auch nachdem die Ausgabe generiert wurde. Sie lassen sich als programmierbare Filter oder Kontrollpunkte verstehen, die bestimmte Regeln durchsetzen, damit Interaktionen sicher, korrekt und auf den vorgesehenen Anwendungsfall ausgerichtet bleiben. Guardrails können schädliche oder irreführende Eingaben blockieren, sicherstellen, dass die Ausgabe des Modells einem bestimmten Format entspricht (etwa gültigem JSON oder einer strukturierten Zusammenfassung), und Antworten kennzeichnen oder zurückweisen, die Anzeichen von Halluzinationen oder ethischen Bedenken aufweisen. So können Entwickler die Unberechenbarkeit von LLMs zuverlässiger handhaben – insbesondere in realen Anwendungen, die sich direkt an Nutzer richten.

Aus Sicherheitssicht spielen Guardrails auch eine wichtige Rolle beim Schutz vor Prompt-Injection-Angriffen, bei denen Nutzer versuchen, die Anweisungen des Systems durch geschickt formulierte Eingaben zu manipulieren oder außer Kraft zu setzen. Keine Lösung bietet vollständigen Schutz, doch Guardrails können verdächtige Muster erkennen, bekannte Angriffsvektoren blockieren und Eingaben bereinigen, bevor sie das LLM erreichen. Bei der Ausgabe können sie Antworten unterdrücken oder ändern, die sensible Informationen enthalten, gegen Richtlinien verstoßen oder unerwünschte Inhalte aufweisen. Damit sind Guardrails ein wichtiger Bestandteil einer umfassenderen KI-Sicherheitsstrategie – insbesondere in Bereichen, in denen Vertrauen, Datenschutz und Integrität entscheidend sind.

So funktionieren Guardrails

Technisch gesehen funktionieren Guardrails, indem sie den Nachrichtenfluss zwischen Nutzern und dem LLM abfangen. Wenn ein Nutzer eine Nachricht sendet, gelangt sie nicht direkt zum Modell. Stattdessen durchläuft sie zunächst ein Input-Guardrail. Diese Schicht prüft die Nachricht auf Dinge wie Prompt-Injection-Versuche, verbotene Schlüsselwörter oder Verstöße gegen die Eingabestruktur. Wird die Eingabe markiert, kann sie blockiert, bereinigt oder umformuliert werden, bevor das Modell sie überhaupt zu sehen bekommt. Nachdem das LLM eine Antwort generiert hat, durchläuft die Ausgabe eine weitere Schicht, das Output-Guardrail. Bevor die Antwort an den Nutzer zurückgegeben wird, prüft diese Schicht sie auf halluzinierte Fakten, unsichere Inhalte, Formatierungsfehler oder Verstöße gegen Geschäftsregeln.

Dieser Prozess ähnelt der Bereinigung und Validierung von Ein- und Ausgaben in der herkömmlichen Softwareentwicklung – eine Vorgehensweise, die Entwicklern bereits vertraut ist. Genauso wenig, wie Sie rohe Nutzereingaben in einem Webformular ungeprüft vertrauen würden, sollten Sie blind darauf vertrauen, was in ein LLM hineingeht oder aus ihm herauskommt. Guardrails übertragen diese Denkweise auf die Welt der KI und helfen Ihnen, Probleme frühzeitig zu erkennen und die Kontrolle über das Verhalten Ihrer Anwendung zu behalten.

Guardrails einfach mit Quarkus implementieren

Quarkus ist ein modernes Java-Framework für die Entwicklung schlanker, leistungsstarker Anwendungen. Es ist für schnelle Startzeiten, geringen Speicherbedarf und entwicklerfreundliche Funktionen bekannt. Besonders hervorzuheben ist die einfache Integration mit LangChain4j, einer Java-orientierten Bibliothek für die Arbeit mit großen Sprachmodellen. Diese Kombination macht Quarkus zu einer hervorragenden Wahl für die Implementierung von KI-Funktionen – insbesondere dank der robusten Unterstützung für Guardrails.

Mit Quarkus und LangChain4j können Sie benutzerdefinierte Guardrails direkt in Ihrer Anwendung mithilfe einfacher Annotationen und Dependency Injection definieren. Dazu implementieren Sie Ihre eigene Validierungslogik in Klassen, die die Schnittstellen InputGuardrail oder OutputGuardrail implementieren. Diese Guardrails dienen als Filter für Ihre KI-Services. Nach ihrer Definition weisen Sie sie mithilfe von Annotationen wie `@InputGuardrails or @OutputGuardrails den Methoden zu, die mit dem LLM interagieren. So können Sie ganz einfach eigene Sicherheitsprüfungen, Validierungen oder Inhaltsrichtlinien einbinden, ohne Ihre Geschäftslogik zu überladen.

Im folgenden Beispiel habe ich einen kleinen KI-Service mit Input- und Output-Guardrails erstellt.

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

Input-Guardrails

Input-Guardrails prüfen und filtern eingehende Nachrichten. Geeignete Nachrichten werden an das LLM weitergegeben, während ungeeignete Ausnahmen auslösen. Dieser proaktive Ansatz verhindert, dass schädliche Prompts das LLM erreichen. Da sich das Verhalten eines LLMs nicht vorhersagen lässt, ist es unmöglich, seine Ausgaben und Funktionsaufrufe zu kontrollieren. Daher ist es hilfreich, schädliche Prompts bereits am Eingang abzufangen.

In diesem Beispiel werden zwei Input-Guardrails implementiert. Das erste Guardrail durchsucht die Eingabe programmatisch nach bestimmten Schlüsselwörtern. Das zweite Guardrail nutzt einen KI-Service, um zu beurteilen, ob eine Eingabe schädlich ist. Ein eigens trainiertes Modell, das schädliche Nachrichten erkennt und filtert, kann eine hervorragende Möglichkeit sein, Eingaben für das LLM zu bereinigen. In diesem Anwendungsfall entscheidet das Modell im InputCheckService, ob ein Prompt personenbezogene Daten (PII) offenlegt.

Mehrere Guardrails für einen einzelnen Service ermöglichen eine flexible Anpassung des Kontrollumfangs.

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

Output-Guardrails

Output-Guardrails können die gesamte Ausgabe Ihres LLM-Services bereinigen. Die potenzielle Gefahr, dass ein LLM unbeabsichtigt Funktionen ausführt, lässt sich dadurch zwar nicht mehr eindämmen. Die Ausgabe des LLM kann jedoch ignoriert oder geändert werden, bevor sie dem Nutzer angezeigt wird.
Ein solches Verfahren eignet sich weiterhin hervorragend, um vulgäre Sprache zu verhindern, Tokens unkenntlich zu machen oder sogar vom LLM erzeugtes Cross-Site-Scripting (XSS) zu verhindern. In diesem Beispiel wird das Wort „JavaScript“ nicht für den Endnutzer angezeigt.

LLM-Ein- und Ausgaben bereinigen

Die Bereinigung und Validierung von Ein- und Ausgaben gibt es schon lange und sie gelten beim Umgang mit Nutzereingaben als bewährte Vorgehensweise. Die Verwendung von Prompts für Large Language Models (LLMs) ändert nichts daran, dass Eingaben von Drittanbietern als potenziell schädlich betrachtet werden sollten. Wenn KI-Systeme zudem eigenständig Funktionen ausführen oder über MCP (Model Context Protocol) in andere Systeme integriert werden können, sind Bereinigung und Validierung wichtiger denn je.

Dieser Artikel hat gezeigt, wie einfach sich Guardrails mit Quarkus implementieren lassen. Der Ansatz ist jedoch nicht auf bestimmte Frameworks oder Programmiersprachen beschränkt. Er sollte als entscheidende Gegenmaßnahme betrachtet werden, damit LLM-gestützte Anwendungen kontrolliert bleiben und wie vorgesehen funktionieren.

Die vollständige Implementierung dieses Projekts finden Sie auf GitHub. Die Quarkus-Dokumentation enthält weitere Informationen zur Verwendung von Guardrails mit Quarkus.