PromptFoo : le secret du déploiement d’une intelligence artificielle fiable et sécurisée

Automatisez les tests et maîtrisez la robustesse de vos agents intelligents. 

IA, Innovation, LLM, Python, Technologie

Ecrit par Vincent

Dans le domaine de l’intelligence artificielle, et plus particulièrement du développement d’applications « intelligentes » ou d’agents conversationnels, la qualité et la fiabilité des réponses fournies par un modèle sont cruciales. À mesure que le système évolue — que ce soit par l’intégration de nouveaux modèles, par l’enrichissement ou la modification de la base de connaissances, ou encore par l’ajout de nouvelles fonctionnalités via l’évolution des prompts — il devient essentiel de mettre en place des stratégies de test et de validation régulières.

Cet article aborde :

La nécessité de déployer des tests continus pour maintenir une qualité constante de l’application face aux évolutions.
Les approches pour s’assurer de la conformité des réponses, ainsi que la robustesse de la solution face à des attaques (red teaming).
Une présentation détaillée de Promptfoo et de la manière de l’intégrer dans un flux de développement IA.

Pourquoi des tests réguliers sont-ils indispensables ?

Évolutions des modèles

Les modèles d’IA, notamment ceux basés sur des réseaux de neurones profonds (transformers, LLM, etc.), peuvent être régulièrement mis à jour pour améliorer leurs performances ou corriger des biais. Or, chaque nouvelle version peut entraîner des changements importants dans la façon dont le modèle répond. Sans une batterie de tests solides, il est impossible de garantir que ces modifications n’induisent pas des régressions ou des effets indésirables.

Évolution de la base de connaissances

Dans de nombreux cas, l’application « intelligente » se base sur un ensemble de données ou une base de connaissances qui est continuellement enrichie ou modifiée. L’ajout de nouvelles informations, la suppression d’éléments obsolètes, la correction d’erreurs… toutes ces actions peuvent influer sur le comportement final de l’agent. Là encore, des tests répétables et régulièrement exécutés permettent de vérifier que les changements n’altèrent pas la qualité des réponses.

Évolution des prompts

Enfin, l’une des particularités des agents conversationnels (assistants virtuels, chatbots) est que la façon de « prompt » (c’est-à-dire d’interroger et de configurer le contexte pour l’IA) joue un rôle fondamental. À chaque fois que l’on introduit un nouveau prompt pour intégrer une fonctionnalité inédite ou préciser un contexte, il est essentiel de vérifier que cette évolution n’entraîne pas de comportement indésirable et respecte les exigences initiales du projet.

Garantir la robustesse face aux attaques : le red teaming

Le red teaming consiste à soumettre le système à des scénarios d’attaque ou d’utilisation malveillante pour en évaluer la résistance. Pour un agent conversationnel, il peut s’agir de tests où l’on tente de contourner ses garde-fous, de le pousser à divulguer des informations sensibles, ou encore d’induire des comportements biaisés ou contraires à la politique de l’entreprise.

L’objectif du red teaming est de cerner les faiblesses afin d’y remédier :

Tester la résilience face à des prompts conçus pour contourner les filtres ou politiques de contenu.
Déterminer si le modèle peut être amené à générer des propos offensants ou diffamatoires.
Vérifier s’il peut être manipulé pour produire des résultats mensongers ou trompeurs.

Le framework PromptFoo

Plusieurs outils ont émergé récemment pour répondre aux besoins de test, d’évaluation et de surveillance des agents conversationnels et des modèles de langage. Parmi eux, Promptfoo est un framework open-source qui vise à automatiser la conception, l’itération et la comparaison de prompts pour différents modèles de langage. L’idée directrice est de fournir un environnement dans lequel on peut facilement 

Définir un ensemble de prompts et de scénarios de test.
Comparer les réponses générées par différents modèles ou différentes versions d’un même modèle.
Définir des métriques d’évaluation qualitatives et quantitatives (cohérence, pertinence, style, ton, etc.).

Principales fonctionnalités

Comparaison A/B des prompts
Promptfoo facilite la comparaison directe entre plusieurs variantes de prompts. Par exemple, si vous testez deux façons de poser la même question à un LLM, l’outil peut générer les réponses et afficher les différences.
Métriques et évaluations customisables
Vous pouvez définir vos propres critères d’évaluation ou utiliser des métriques prédéfinies. En plus de la comparaison textuelle brute, il est possible d’intégrer des outils externes (analyse de sentiments, scoring de similarité sémantique, etc.).
Intégration avec CI/CD
Promptfoo s’intègre dans vos pipelines de développement. Avant chaque mise en production, vous pouvez automatiser la génération et l’évaluation des réponses, afin de vous assurer qu’aucune régression n’est introduite.
Possibilité de tester plusieurs modèles simultanément
Promptfoo offre la flexibilité de tester différents modèles pour un même prompt, et de déterminer lequel convient le mieux à vos cas d’usage ou offre la meilleure qualité de réponse.
Support des prompts contextuels avancés
Grâce à sa conception modulable, Promptfoo permet d’intégrer des contextes complexes (par exemple l’historique d’une conversation, un ensemble de documents, etc.) dans les prompts pour des tests plus proches de la réalité.
Intégration du Read Teaming
Promptfoo se révèle particulièrement utile pour intégrer des scénarios de red teaming au sein même du processus de validation et de test. Le red teaming vise à soumettre le système à des scénarios d’attaques ou d’usages malveillants afin d’en évaluer la robustesse et d’identifier ses faiblesses. Promptfoo propose ainsi une large bibliothèque de scénario prêts à l’emploi facilitant ainsi le test de vos applications.

Exemple de workflow avec Promptfoo

Promptfoo est développé en javascript et peut se lancer très simplement avec la commande npx.

Pour initialiser un environnement de test, la commande ci dessous vous guide à travers une série de questions afin d’adapter au mieux la configuration.

npx promptfoo@latest init

Dans notre exemple, nous allons exploiter les possibilités du framework d’executer un script Python pour tester un agent développé avec le framework LlamaIndex et mettant en oeuvre un workflow s’appuyant sur un RAG avancé et des techniques de décomposition et de raisonnement.

Promptfoo se configure via un fichier Yaml qui dans notre exemple comporte les entrées suivantes:

1 – Rapide description de la série de tests

description: "Regression tests"

2 – Identification de la target

targets:
  - id: "file://test_wf_v1.py"
    label: 'Wokflow v1'
    config:
      agent_id: "some_internal_id"
  - id: "file://test_wf_v2.py"
    label: 'Wokflow v2'
    config:
      agent_id: "some_internal_id"

Les targets identifient le ou les agents à tester. Déclarer plusieurs agents permet de comparer plusieurs version de l’agent et de mesurer ainsi l’impact d’une mise à jour (changement du modèle sous-jacent, mise à jour du prompt de raisonnement…).

Pour chaque target:

id: identifiant de la target, il cible un fichier python spécifique
label: associe un label à la target pour une meilleur lisibilité des rapports
config: permet de passer
- des paramètres supportés par Promptfoo comme pythonExecutable pour forcer le chemin vers l’exécutable Python à utiliser,
- des paramètres custom (ici agent_id) qui seront accessibles depuis le script.

Le script Python doit implémenter l’interface:

def call_api(prompt: str, options: Dict[str, Any], context: Dict[str, Any]) -> ProviderResponse:
  ...

Dans notre exemple:

#
# Our custom business logic 
#
async def run_agent(agent_id: str, query: str):
    try:
        workflow = ReasoningWorkflowV1(logger, timeout=120, verbose=False)
        workflow_response = await workflow.run(
            agent_id=agent_id,
        )
    except WorkflowTimeoutError as e:
        logger.error("Workflow timeout", e)
    except Exception as e:
        logger.error("Error", e)
    return results

#
# Promptfoo endpoint
#
def call_api(query: str, options: Dict[str, Any], context: Dict[str, Any]):
    agent_id = options["config"]["agent_id"]
    workflow_result = asyncio.run(run_agent(agent_id, query))
    return {"output": workflow_result["response""]}

Si on analyse le code ci-dessus:

agent_id = options["config"]["agent_id"] récupère le paramètre déclaré dans le fichier de configuration,
workflow_result = asyncio.run(run_agent(agent_id, query)) exécute le workflow LlamaIndex,
return {"output": workflow_result["response""]} retourne la réponse au framework pour évaluation.

Pour plus d’informations sur l’intégration de scripts Python: https://www.promptfoo.dev/docs/providers/python/ .

3 – Tests de non regression

Promptfoo propose différentes approches pour organiser les tests. Ici, par simplicité, nous intègrerons directement les tests dans le fichier de configuration.

prompts:
  - "{{topic}}"
tests:
  - vars:
      topic: "Can I speak with someone"
    assert:
      - type: llm-rubric
        value: "Invite to contact customer support"
      - type: icontains
        value: "https://www.bostik.com/uk/en_GB/customer-support/"
  - vars:
      topic: "What are the differences between Flexacryl and Flashband"
    assert:
      - type: icontains-all
        value:
          - "https://www.bostik.com/uk/en_GB/catalog/product/construction/emea/uk/product-flexacryl-instant-waterproof-compound/"
          - "https://www.bostik.com/uk/en_GB/catalog/product/construction/emea/uk/product-flashband/"

Sous prompts, nous déclarons les prompts à tester. Dans notre exemple, nous reprenons simplement la variable topic déclarée pour chaque test.

Sous tests, nous listons nos cas de tests avec:

vars: qui regroupe les variables du test, ici topic qui définie la question à poser à notre workflow
assert: les définit les assertions que doit remplir notre la réponse pour être valide.

Promptfoo support une très large variété d’assertion regroupées en 2 familles:

les assertions déterministes (https://www.promptfoo.dev/docs/configuration/expected-outputs/deterministic/) qui évalue des éléments objectifs de la réponses,
les assertions évaluées par des modèles (https://www.promptfoo.dev/docs/configuration/expected-outputs/model-graded/) qui évalue des éléments subjectifs de la réponse.

Parmi les fonctionnalité très appréciables de Prompfoo, on notera l’intégration native du Google Sheets pour la déclaration des tests (https://www.promptfoo.dev/docs/integrations/google-sheets/).

Pour executer les tests, il suffit de lancer la commande:

npx promptfoo@latest eval --config <my_promptfoo_config.yaml>

Une fois les tests executer, Promptfoo propose une interface très visuelle pour analyser les résultats:

npx promptfoo@latest view --yes

Cette interface permet d’explorer en profondeur les résultats obtenu et d’identifier facilement les faiblesses de la solution. Lorsque nous comparons différentes version, les résultats sont présentés côte à côte pour faciliter l’analyse.

4 – Red teaming

Les pluggins

Promptfoo s’appuie sur des plugins qui vont générer les prompts sur différentes thématiques. La liste des plugins est disponible dans la documentation (https://www.promptfoo.dev/docs/red-team/configuration/#plugins) ou elle peut être obtenue en ligne de commande:

npx promptfoo@latest redteam plugins

Promptfoo propose également un ensemble de plugins prédéfinies basées sur les principaux standard de sécurité (https://www.promptfoo.dev/docs/red-team/configuration/#plugin-collections ):

NIST AI Risk Management Framework (AI RMF)
OWASP Top 10 for Large Language Model Applications
OWASP Top 10 for API Security
MITRE ATLAS framework for AI system threats

Les stratégies

Les stratégies de red-teaming permettent de définir les méthodes mise en oeuvre pour attaquer et tester l’application. Comme pour les plugins, Promptfoo propose un ensemble de stratégies out of the box (https://www.promptfoo.dev/docs/red-team/configuration/#strategies).

Exemple de configuration

Le red teaming se configure à travers une section dédiée du fichier de configuration.

redteam:
  numTests: 10
  plugins:
    - "nist:ai:measure"
  strategies:
    - "jailbreak"
  language: "English"

Avec:

numTests: nombre par défaut de tests à générer par plugin
plugins: plugins à utiliser pour la génération des tests
strategies: les stratégies à appliquer en combinaison des plugins (il est également possible de définir des stratégies qui ne s’appliquent qu’à certains plugins)
language: langue à utiliser pour les tests (peut-être surchargée au niveau de chaque plugin)

Execution des tests et analyse des résultats

Pour executer les tests, il suffit de lancer la commande:

npx promptfoo@latest redteam run --config <my_promptfoo_config.yaml>

Une fois les tests executer, Promptfoo propose une interface très visuelle pour analyser les résultats:

npx promptfoo@latest redteam report

Conclusion

Au terme de cet article, Promptfoo apparaît comme un outil à la fois simple à mettre en œuvre et extrêmement complet, offrant des fonctionnalités permettant de tester la pertinence fonctionnelle des réponses d’un agent conversationnel ou d’une application d’IA, tout en intégrant en continu des scénarios de red teaming au sein du processus de validation. Qu’il s’agisse de mesurer la qualité intrinsèque des réponses, de comparer différents prompts ou de s’assurer que les garde-fous de sécurité fonctionnent correctement face à des usages malveillants, PromptFoo propose une approche modulaire et personnalisable.

Ses nombreuses possibilités d’intégration, notamment dans des chaînes CI/CD, en font un atout majeur pour s’insérer de manière fluide dans les workflows de développement. Les équipes peuvent ainsi automatiser et industrialiser leurs tests, détecter rapidement d’éventuelles régressions ou vulnérabilités, et réagir plus efficacement en ajustant prompts ou configurations.

Pour toutes ces raisons, Promptfoo se positionne comme l’outil idéal pour quiconque souhaite démarrer et automatiser le test de ses applications intelligentes, en assurant à la fois la fiabilité des réponses et la robustesse globale du système.

Vous souhaitez transformer vos données en un avantage compétitif avec des applications d’IA avancées ? Contactez-nous pour discuter de la manière dont nous pouvons intégrer ces technologies dans vos projets et vous aider à optimiser vos processus métier, tout en améliorant l’expérience utilisateur et la qualité de vos services.