Renforcez vos agents LLM à l’aide de garde-fous

Les guardrails, ou garde-fous en français, sont des mécanismes de contrôle et de sécurité intégrés aux applications utilisant des modèles de langue (LLM). Ils agissent comme des filtres intelligents qui encadrent et dirigent les réponses du modèle, assurant ainsi que les sorties restent pertinentes, sûres et alignées avec les objectifs de l'application.

Pourquoi avoir besoin d’un guardrail ?

L'utilisation de guardrails devient cruciale pour plusieurs raisons :

• Sécurité et fiabilité : Les guardrails permettent de prévenir les réponses inappropriées, offensantes ou potentiellement dangereuses du modèle.

• Cohérence des réponses : Ils assurent que les réponses du modèle restent cohérentes avec le contexte métier et les objectifs spécifiques de l'application.

• Conformité réglementaire : Dans certains secteurs comme la santé ou la finance, les guardrails peuvent aider à respecter les obligations légales et réglementaires.

• Expérience utilisateur optimisée : En guidant les réponses du modèle, ils contribuent à une meilleure expérience utilisateur avec des réponses plus pertinentes et mieux structurées.

L'implémentation de guardrails devient ainsi un élément essentiel dans le développement d'applications robustes basées sur les LLM, particulièrement dans un contexte professionnel où la qualité et la fiabilité des réponses sont primordiales.

Les différentes approches

Par API

L'approche par API consiste à utiliser des services cloud qui fournissent des mécanismes de contrôle pré-construits pour les LLM. Ces services offrent plusieurs avantages :

• Facilité d'intégration : Les API sont généralement bien documentées et simples à implémenter dans une application existante.

• Maintenance externalisée : Les fournisseurs cloud gèrent la mise à jour et l'amélioration continue des guardrails.

Les différents fournisseurs de Cloud proposent aujourd’hui ce genre d’API. AWS Bedrock propose Guardrails. Google propose quant à lui Check Guardrails API (mais en private preview lors de l’écriture de l’article). etc.

Côté Google Google, son API permet de générer un score relatif à un nombre prédéfini de catégories comme la violence ou la présence d’information personnelle par exemple.

Côté AWS, on peut définir un guardrails comme la combinaison de plusieurs contrôles/filtres. On pourra alors appeler ce guardrail par son identifiant depuis notre code.

Ces solutions sont particulièrement adaptées aux entreprises qui souhaitent déployer rapidement des applications LLM sécurisées sans avoir à développer leurs propres mécanismes de contrôle.

Par l’utilisation d’une bibliothèque tierce

L’approche par bibliothèque tierce consiste à inclure les guardrails au plus proche de son code.

Prenons l’exemple de la bibliothèque open source Guardrails AI. Elle est accompagnée d’un dépôt de guardrails que l’on peut importer dans son code. L’équipe pourra également définir son propre guardrail personnalisé. Il suffira alors d’entourer les appels à son LLM avec les guardrails que l’on souhaite utiliser, et de définir le comportement attendu lorsqu’un guardrail détecte une violation de sa règle.

Voici un exemple simple de l’utilisation de cette bibliothèque dans un programme utilisant langchain :

import os

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_google_vertexai import ChatVertexAI

from guardrails import Guard
from guardrails.hub import CompetitorCheck, ToxicLanguage
from guardrails.types.on_fail import OnFailAction

guard = Guard().use_many(
    CompetitorCheck(competitors=[...], on_fail=OnFailAction.get(OnFailAction.EXCEPTION)),
    ToxicLanguage(on_fail=OnFailAction.get(OnFailAction.FILTER)),
)

model = ChatVertexAI(
    model=os.environ.get("APP_MODEL"),
    project=os.environ.get("GCP_PROJECT_ID"),
    location=os.environ.get("GCP_LOCATION")
)

prompt = ChatPromptTemplate.from_template("Answer this question {question}")
output_parser = StrOutputParser()
chain = prompt | guard.to_runnable() | model | output_parser

print(chain.invoke({"question": "..."})) 

Cette approche présente plusieurs avantages significatifs :

• Flexibilité et personnalisation : Les développeurs peuvent créer et adapter leurs propres guardrails en fonction des besoins spécifiques de leur application.

• Contrôle total : L'équipe maîtrise entièrement l'implémentation et peut ajuster finement les comportements des guardrails.

• Indépendance cloud : Pas de dépendance à un fournisseur cloud spécifique, ce qui évite le vendor lock-in

• Performance : Pour les vérifications pouvant être effectuées localement, les temps de réponse peuvent être optimisés

• Coût maîtrisé : Pas de frais liés à l'utilisation d'APIs tierces, particulièrement avantageux pour les applications à fort trafic.

Cette approche est particulièrement adaptée aux équipes techniques qui souhaitent garder un contrôle précis sur leurs mécanismes de sécurité et qui ont des besoins spécifiques non couverts par les solutions API standard.

Quelle approche devriez-vous choisir ?

Le choix entre les différentes approches dépend de plusieurs facteurs clés :

• Ressources techniques : Les équipes disposant d'une forte expertise technique peuvent tirer davantage profit de l'approche par bibliothèque, tandis que l'approche API est plus adaptée aux équipes avec des ressources techniques limitées.

• Délai de mise en œuvre : Les API offrent une solution plus rapide à déployer, alors que l'implémentation de bibliothèques nécessite plus de temps de développement et de tests.

• Besoins spécifiques : Des cas d'usage très particuliers peuvent nécessiter des guardrails personnalisés, favorisant l'approche par bibliothèque.