DEV Community

Cover image for Comment tester les applications LLM : Guide complet de Promptfoo (2026)
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

Comment tester les applications LLM : Guide complet de Promptfoo (2026)

#testing #llm #tutorial #ai

En bref

Promptfoo est un framework open-source d'évaluation et de red-teaming de LLM qui aide les développeurs à tester systématiquement les applications d'IA. Il prend en charge plus de 90 fournisseurs de modèles, offre plus de 67 plugins d'attaque de sécurité, et fonctionne 100 % localement pour garantir la confidentialité. Avec 1,6 million de téléchargements npm et une utilisation en production par des entreprises desservant plus de 10 millions d'utilisateurs, il est devenu la norme pour le test de LLM. Pour démarrer rapidement :

npm install -g promptfoo
promptfoo init --example getting-started
Enter fullscreen mode Exit fullscreen mode

Essayez Apidog dès aujourd'hui

Introduction

Vous avez investi des semaines dans la création d’un chatbot de support client basé sur l’IA. En développement, il semblait parfait. Mais dès la mise en production, les utilisateurs ont trouvé des moyens de contourner la sécurité, d’obtenir des données sensibles ou de provoquer des réponses incohérentes.

Ce scénario est fréquent. Beaucoup d’équipes déploient des applications LLM en se fiant à des tests manuels, pour découvrir plus tard des failles en production. Corriger ces problèmes après le lancement coûte 100 fois plus cher que de les détecter en amont.

Promptfoo automatise et systématise les tests des applications LLM : évaluez vos prompts sur plusieurs modèles, effectuez des analyses de sécurité (red-team), et détectez les régressions avant qu’elles n’atteignent les utilisateurs.

Ce guide, basé sur l’analyse du code source de promptfoo (v0.121.2) et sur des tests pratiques, vous montre comment configurer des évaluations, lancer des audits de sécurité, intégrer l’outil en CI/CD et éviter les erreurs courantes. À la fin, vous disposerez d'une suite de tests robuste pour votre application LLM, prête à être déployée sereinement.

💡 Si vous testez également des API ou souhaitez valider leur comportement parallèlement à vos tests LLM, Apidog fournit une plateforme unifiée pour concevoir, tester et documenter vos API. Utilisez promptfoo pour l’évaluation LLM et Apidog pour la validation API, ensemble dans votre workflow.

Qu'est-ce que Promptfoo et pourquoi en avez-vous besoin

Promptfoo est un CLI et une bibliothèque Node.js dédiée à l’évaluation et à la sécurité des applications LLM. Il s’adapte aux spécificités de l’IA là où les outils de test classiques échouent, en particulier à cause de la non-déterminisme des sorties LLM.

Représentation visuelle de Promptfoo évaluant un modèle LLM

Ce que Promptfoo apporte :

  • Assertions sémantiques : vérification du sens, pas uniquement du texte exact.
  • Évaluations notées par LLM : un modèle évalue la sortie d’un autre.
  • Comparaison multi-modèles : testez le même prompt sur GPT-4, Claude, etc.
  • Plugins de sécurité : détectent automatiquement les vulnérabilités.

Tout fonctionne localement. Vos données restent sur votre machine, sauf utilisation volontaire du cloud.

Le problème que Promptfoo résout

Les tests manuels présentent trois limites majeures :

  1. Pas de détection de régression : impossible de savoir si une mise à jour casse une fonctionnalité existante.
  2. Lacunes de couverture : les cas limites et entrées adverses passent inaperçus.
  3. Pas de métriques : aucune mesure objective des progrès ou comparaisons entre modèles.

Promptfoo remplace cela par des évaluations automatisées, exécutables à chaque changement, avec des rapports détaillés (succès/échec, coûts, latence).

Qui utilise Promptfoo

Avec 1,6 million de téléchargements npm, Promptfoo est utilisé pour :

  • Chatbots nécessitant cohérence et précision
  • Pipelines de génération de contenu devant respecter la voix de marque
  • Applications santé/fintech à fortes contraintes de conformité
  • Systèmes sensibles à la sécurité

Depuis mars 2026, Promptfoo a rejoint OpenAI, tout en restant open-source sous licence MIT.

Démarrage rapide : Installer et exécuter votre première évaluation

Installation

Installez promptfoo globalement ou utilisez-le via npx :

# Installation globale (recommandée)
npm install -g promptfoo

# Ou exécution sans installation
npx promptfoo@latest

# Sur macOS avec Homebrew
brew install promptfoo

# Ou en Python via pip
pip install promptfoo
Enter fullscreen mode Exit fullscreen mode

Configurez vos clés API :

export OPENAI_API_KEY=sk-abc123
export ANTHROPIC_API_KEY=sk-ant-xxx
Enter fullscreen mode Exit fullscreen mode

Créer votre première évaluation

Initialisez un projet exemple :

promptfoo init --example getting-started
cd getting-started
Enter fullscreen mode Exit fullscreen mode

Un fichier promptfooconfig.yaml est généré avec prompts, fournisseurs et tests.

Lancez l’évaluation :

promptfoo eval
Enter fullscreen mode Exit fullscreen mode

Ouvrez les résultats dans l’interface web :

promptfoo view
Enter fullscreen mode Exit fullscreen mode

L’UI s’ouvre sur localhost:3000 pour comparer les sorties de chaque modèle et afficher l’état de chaque assertion.

Comprendre le fichier de configuration

promptfooconfig.yaml structure votre suite de tests :

description: "Ma Première Suite d'Évaluation"

prompts:
  - prompts/greeting.txt
  - prompts/farewell.txt

providers:
  - openai:gpt-4o
  - anthropic:claude-sonnet-4-5

tests:
  - vars:
      input: "Hello"
    assert:
      - type: contains
        value: "Hi"
      - type: latency
        threshold: 3000
Enter fullscreen mode Exit fullscreen mode
  • prompts : fichiers ou textes à évaluer
  • providers : modèles testés (plus de 90 disponibles)
  • tests : cas de test avec variables et assertions

Mettez ce fichier sous contrôle de version et exécutez-le en CI à chaque PR.

Fonctionnalités principales : Ce que Promptfoo peut faire

1. Évaluations automatisées

Définissez des cas de test, des attentes, et lancez-les sur vos modèles.

Types d’assertions

Promptfoo propose plus de 30 assertions intégrées :

Assertion Objectif
contains La sortie contient une sous-chaîne
equals Correspondance exacte
regex Motif regex
json-schema Validation de structure JSON
javascript Fonction JS personnalisée
python Fonction Python personnalisée
llm-rubric Notation par un LLM tiers
similar Similarité sémantique
latency Temps de réponse sous seuil
cost Coût par requête sous seuil

Exemple avec plusieurs assertions :

tests:
  - vars:
      question: "Quelle est la capitale de la France ?"
    assert:
      - type: contains
        value: "Paris"
      - type: javascript
        value: output.length < 100
      - type: latency
        threshold: 2000
      - type: cost
        threshold: 0.001
Enter fullscreen mode Exit fullscreen mode

Évaluations notées par LLM

Utilisez l’assertion llm-rubric pour des critères subjectifs :

assert:
  - type: llm-rubric
    value: "La réponse doit être utile, inoffensive et honnête"
Enter fullscreen mode Exit fullscreen mode

Choisissez un modèle LLM dédié à l’évaluation pour optimiser les coûts.

2. Tests de sécurité et Red Teaming

Automatisez la recherche de vulnérabilités grâce au module red team de Promptfoo.

Diagramme illustrant les capacités de red-teaming de Promptfoo pour les applications LLM

Vecteurs d’attaque pris en charge

Catégorie Ce qu’il teste
Injection de prompt Injections directes, indirectes, contextuelles
Jailbreaks Changement de persona, contournement de rôle
Exfiltration de données SSRF, extraction de prompt, fuite de prompt
Contenu nuisible Discours de haine, activités dangereuses, etc.
Conformité Fuite de PII, violations HIPAA, données financières
Audio/Visuel Attaques audio et images

Exécuter une analyse Red Team

Démarrez une analyse red team :

promptfoo redteam init
promptfoo redteam run
promptfoo redteam report [directory]
Enter fullscreen mode Exit fullscreen mode
  • redteam run : génère des sondes d’attaque, les teste, classe les vulnérabilités.
  • Les résultats incluent la sévérité et des recommandations.

Exemple de sortie :

Résumé des vulnérabilités :
- Critique : 2 (fuite PII, extraction de prompt)
- Élevé : 5 (jailbreaks, injections)
- Moyen : 12 (biais, incohérences)
- Faible : 23 (violations mineures)
Enter fullscreen mode Exit fullscreen mode

Corrigez les critiques avant tout déploiement.

3. Analyse de code pour les Pull Requests

Intégrez Promptfoo à GitHub Actions pour scanner chaque PR :

# .github/workflows/promptfoo-scan.yml
name: Tests LLM
on: [pull_request]
jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - run: npm install -g promptfoo
      - run: promptfoo eval -c promptfooconfig.yaml
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
Enter fullscreen mode Exit fullscreen mode

Détectez rapidement :

  • Clés API codées en dur,
  • Prompts non sécurisés,
  • Absence de validation d’entrée,
  • Vecteurs d’injection potentiels.

4. Comparaison de modèles

Comparez plusieurs modèles en parallèle pour choisir le meilleur :

promptfoo eval
promptfoo view
Enter fullscreen mode Exit fullscreen mode

L’interface web affiche :

  • Taux de réussite par modèle,
  • Coût pour 1000 requêtes,
  • Latence,
  • Différences qualitatives.

Données à l’appui, vous pouvez sélectionner le modèle le plus performant et rentable.

Fournisseurs pris en charge : Plus de 90 intégrations LLM

Promptfoo prend en charge nativement +90 fournisseurs. Testez vos prompts sur OpenAI, Anthropic, Google, Amazon, Meta, Ollama, etc., sans changer votre code.

Principaux fournisseurs

Fournisseur Modèles principaux
OpenAI GPT-4, GPT-4o, GPT-4o-mini, o1, o3
Anthropic Claude 3.5/3.7/4.5/4.6, modèles de réflexion
Google Gemini 1.5/2.0, Vertex AI
Microsoft Azure OpenAI, Phi
Amazon Bedrock (Claude, Llama, Titan)
Meta Llama 3, 3.1, 3.2 (via plusieurs fournisseurs)
Ollama Modèles locaux (Llama, Mistral, Phi)

Fournisseurs personnalisés

Ajoutez un modèle non supporté via un provider personnalisé Python/JS.

Python :

# custom_provider.py
from typing import Any

class CustomProvider:
    async def call_api(self, prompt: str, options: dict, context: dict) -> dict:
        response = await my_async_api.generate(prompt)
        return {
            "output": response.text,
            "tokenUsage": {
                "total": response.usage.total_tokens,
                "prompt": response.usage.prompt_tokens,
                "completion": response.usage.completion_tokens
            }
        }
Enter fullscreen mode Exit fullscreen mode

JavaScript :

// customProvider.js
export default class CustomProvider {
  async callApi(prompt) {
    return {
      output: await myApi.generate(prompt),
      tokenUsage: { total: 50, prompt: 20, completion: 30 }
    };
  }
}
Enter fullscreen mode Exit fullscreen mode

Configuration :

providers:
  - id: file://custom_provider.py
    config:
      api_key: ${MY_API_KEY}
Enter fullscreen mode Exit fullscreen mode

Interface en ligne de commande : Commandes essentielles

Commandes principales 

# Exécuter les évaluations
promptfoo eval -c promptfooconfig.yaml

# Ouvrir l'UI web
promptfoo view

# Partager les résultats
promptfoo share

# Red team
promptfoo redteam init
promptfoo redteam run

# Configuration
promptfoo init
promptfoo validate [config]

# Gestion des résultats
promptfoo list
promptfoo show <id>
promptfoo delete <id>
promptfoo export <id>

# Utilitaires
promptfoo cache clear
promptfoo retry <id>
Enter fullscreen mode Exit fullscreen mode

Options utiles 

--no-cache              # Désactive le cache pour des résultats frais
--max-concurrency <n>   # Limite la concurrence API
--output <file>         # Résultats au format JSON
--verbose               # Mode débogage
--env-file <path>       # Charger les variables d'environnement
--filter <pattern>      # Exécuter des tests spécifiques
Enter fullscreen mode Exit fullscreen mode

Exemple : évaluation personnalisée 

promptfoo eval \
  -c promptfooconfig.yaml \
  --no-cache \
  --max-concurrency 3 \
  --output results.json \
  --env-file .env
Enter fullscreen mode Exit fullscreen mode

Intégration CI/CD : Automatiser les tests LLM

Automatisez les évaluations dans votre pipeline CI/CD.

Exemple GitHub Actions 

name: Tests LLM
on: [push, pull_request]
jobs:
  eval:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - run: npm install -g promptfoo
      - run: promptfoo eval -c promptfooconfig.yaml
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
Enter fullscreen mode Exit fullscreen mode

Portes de qualité

Dans votre config :

commandLineOptions:
  threshold: 0.8  # 80% requis pour valider
Enter fullscreen mode Exit fullscreen mode

La CI échoue si le score est insuffisant.

Mise en cache en CI 

- uses: actions/cache@v4
  with:
    path: ~/.cache/promptfoo
    key: ${{ runner.os }}-promptfoo-${{ hashFiles('promptfooconfig.yaml') }}
Enter fullscreen mode Exit fullscreen mode

Le cache réduit les coûts et accélère la CI.

Interface utilisateur Web : Visualiser et partager les résultats

Lancez promptfoo view pour accéder à l’UI interactive.

Fonctionnalités

  • Matrice d’évaluation : comparaison côte à côte
  • Filtrage : par statut/fournisseur
  • Vue Diff : voir les changements entre exécutions
  • Partage : liens partageables
  • Mises à jour en temps réel

Accès et sécurité

  • Par défaut : localhost:3000 avec protection CSRF.
  • Ne pas exposer à l’extérieur sans précaution.
  • Pour un partage en équipe, utilisez promptfoo share ou auto-hébergez avec authentification.

Base de données et mise en cache

Emplacement du cache

  • macOS/Linux : ~/.cache/promptfoo
  • Windows : %LOCALAPPDATA%\promptfoo

Utilisez --no-cache pendant le développement pour forcer des résultats frais.

Emplacement de la base de données

  • Toutes plateformes : ~/.promptfoo/promptfoo.db (SQLite)

Ce fichier stocke l’historique des évaluations.

Modèle de sécurité : Ce que vous pouvez faire confiance

Promptfoo distingue entrées de confiance et entrées non fiables.

Entrées fiables (traitées comme du code)

  • Fichiers de configuration
  • Assertions JS/Python/Ruby
  • Config des providers
  • Fonctions de transformation

Entrées non fiables (données uniquement)

  • Texte des prompts
  • Variables de test
  • Sorties modèles
  • Contenu distant

Recommandations de renforcement

  1. Exécutez dans un conteneur/VM à privilèges minimaux
  2. Utilisez des clés API dédiées, à privilèges restreints
  3. Ne stockez pas de secrets dans les prompts/config
  4. Restreignez la sortie réseau pour le code tiers
  5. Gardez l’UI locale privée

Performance : Optimiser vos évaluations

Conseils d’optimisation

  1. Mise en cache : accélère les exécutions répétées
  2. Ajustez la concurrence : --max-concurrency équilibre rapidité/limites API
  3. Filtrez les tests : --filter pour cibler des cas précis
  4. Échantillonnez : --repeat pour travailler sur des sous-ensembles

Mise à l’échelle

  • Utilisez l’ordonnanceur (src/scheduler/) pour l’exécution distribuée
  • Génération distante possible pour décharger le calcul
  • Exportez les résultats (ex : Google Sheets) pour partage

Extensibilité : Construire des fonctionnalités personnalisées

Assertions personnalisées

JavaScript :

// assertions/customCheck.js
export default function customCheck(output, context) {
  const pass = output.includes('expected');
  return {
    pass,
    score: pass ? 1 : 0,
    reason: pass ? 'La sortie correspond' : 'Contenu attendu manquant'
  };
}
Enter fullscreen mode Exit fullscreen mode

Utilisation dans la config :

assert:
  - type: file://assertions/customCheck.js
Enter fullscreen mode Exit fullscreen mode

Serveur MCP

Lancez le serveur pour intégration avec des assistants IA :

promptfoo mcp
Enter fullscreen mode Exit fullscreen mode

Permet :

  • Exécution d’évaluations depuis un chat
  • Accès red team
  • Requêtes sur les résultats stockés
  • Génération de nouveaux cas de test

Cas d'utilisation réels

Chatbot de support client

  • 500 cas de test couvrant tous les scénarios
  • Comparaison GPT-4 / Claude
  • Analyses red team régulières
  • Blocage CI si des tests échouent

Impact : 90% de baisse des incidents clients post-déploiement.

Pipeline de génération de contenu

  • Vérification du ton et du style via LLM
  • Seuils de latence stricts
  • Suivi du coût API
  • Sélection du fournisseur le plus rentable

Impact : Voix de marque cohérente et -40% sur les coûts API.

Application de santé

  • Analyses red team pour conformité HIPAA
  • Assertions médicales custom
  • Évaluations locales pour la confidentialité
  • Audit trail intégré

Impact : Audit SOC 2 réussi grâce à la traçabilité promptfoo.

Conclusion

Promptfoo systématise et automatise les tests des LLM, remplaçant les validations manuelles par des évaluations objectives, reproductibles et sécurisées.

À retenir :

  • Installation rapide : npm install -g promptfoo puis promptfoo init
  • Utilisez des assertions sémantiques, pas que des égalités de chaînes
  • Auditez la sécurité avec les outils red team intégrés
  • Intégrez à votre CI/CD pour éviter les régressions
  • Comparez objectivement les modèles
  • Étendez avec des providers et assertions personnalisés

L’avenir du développement IA est piloté par la donnée. Avec promptfoo, structurez, testez et sécurisez vos applications LLM à grande échelle.

Si vous travaillez aussi avec des API, combinez promptfoo et Apidog. Apidog gère la conception, le test et la documentation des API, promptfoo l’évaluation LLM — la couverture complète pour vos applications modernes.

FAQ

À quoi sert promptfoo ?

Promptfoo sert à tester et évaluer les applications LLM. Il exécute des tests automatisés sur les prompts, compare les sorties entre modèles et effectue des audits de sécurité.

Promptfoo est-il gratuit ?

Oui, promptfoo est open-source (MIT). Utilisation gratuite pour projets perso et pro. Les fonctions cloud/support entreprise peuvent être payantes.

Comment installer promptfoo ? 

npm install -g promptfoo
Enter fullscreen mode Exit fullscreen mode

Ou utilisez :

  • npx promptfoo@latest
  • brew install promptfoo (macOS)
  • pip install promptfoo (Python)

Quels modèles promptfoo prend-il en charge ?

Plus de 90 fournisseurs : OpenAI (GPT-4, GPT-4o, o1), Anthropic (Claude 3.5/4/4.5), Google (Gemini), Microsoft (Azure OpenAI), Amazon Bedrock, modèles locaux via Ollama, etc.

Comment exécuter une analyse red team ? 

promptfoo redteam init
promptfoo redteam run
promptfoo redteam report
Enter fullscreen mode Exit fullscreen mode

Puis-je utiliser promptfoo en CI/CD ?

Oui. Installez promptfoo dans votre pipeline et exécutez promptfoo eval. Définissez un seuil (threshold) pour faire échouer la CI si les taux de réussite sont insuffisants.

Promptfoo envoie-t-il mes données à des serveurs externes ?

Non. Par défaut, tout s’exécute localement. Vos prompts et vos données restent sur votre machine, sauf si vous activez explicitement les fonctions cloud. Le cache et la base sont stockés localement.

Comment comparer des modèles avec promptfoo ?

Listez plusieurs fournisseurs dans la config, exécutez promptfoo eval, puis visualisez dans l’UI web (promptfoo view) pour des stats comparatives détaillées.

Top comments (0)