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

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 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. Commencez avec npm install -g promptfoo et promptfoo init --example getting-started.

Introduction

Vous avez passé des semaines à construire votre chatbot de support client alimenté par l'IA. Il répondait parfaitement aux questions pendant le développement. Puis les utilisateurs ont commencé à trouver des moyens de lui faire divulguer des données sensibles, de contourner les garde-fous de sécurité et de donner des réponses incohérentes.

Ce scénario se produit chaque jour. Les équipes déploient des applications LLM basées sur l'intuition et les tests manuels, pour ensuite découvrir des vulnérabilités et des problèmes de qualité en production. Le coût de la résolution de ces problèmes après le lancement est 100 fois plus élevé que de les détecter pendant le développement.

Promptfoo résout ce problème en apportant des tests systématiques et automatisés aux applications LLM. Il vous permet d'évaluer les prompts sur plusieurs modèles, d'effectuer des évaluations de sécurité par des équipes rouges (red-team) et de détecter les régressions avant qu'elles n'atteignent les utilisateurs.

J'ai analysé la base de code de promptfoo (version 0.121.2) et testé ses fonctionnalités principales pour vous offrir ce guide complet. Vous apprendrez comment configurer des évaluations, exécuter des analyses de sécurité, intégrer avec CI/CD et éviter les pièges courants.

À la fin, vous disposerez d'une suite de tests fonctionnelle pour votre application LLM et saurez comment la déployer en toute confiance.

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

Promptfoo est un outil en ligne de commande et une bibliothèque Node.js pour évaluer et tester la sécurité (red-teaming) des applications LLM. Considérez-le comme un framework de test conçu spécifiquement pour les particularités du développement de l'IA.

Les outils de test traditionnels échouent avec les LLM car les sorties sont non déterministes. Vous ne pouvez pas affirmer des correspondances de chaînes exactes lorsque le même prompt produit des réponses différentes à chaque fois. Promptfoo résout ce problème avec :

• Assertions sémantiques qui vérifient le sens au lieu du texte exact
• Évaluations notées par LLM où un modèle évalue la sortie d'un autre
• Comparaison multi-modèles pour tester le même prompt sur GPT-4, Claude et d'autres
• Plugins de sécurité qui recherchent automatiquement les vulnérabilités

L'outil fonctionne localement sur votre machine. Vos prompts et vos données de test ne quittent jamais votre environnement, sauf si vous choisissez d'utiliser les fonctionnalités cloud. Cette conception axée sur la confidentialité le rend adapté aux tests avec des données sensibles.

Le problème que Promptfoo résout

La plupart des équipes testent manuellement les applications LLM. Elles envoient quelques prompts, lisent les sorties et décident si les choses semblent bonnes. Cette approche présente trois défauts fatals :

1. Pas de détection de régression - Vous ne pouvez pas savoir si une mise à jour du modèle a cassé une fonctionnalité existante
2. Lacunes de couverture - Les tests manuels manquent les cas limites et les entrées adverses
3. Pas de métriques - Vous ne pouvez pas suivre les améliorations ni comparer les modèles objectivement

Promptfoo remplace cela par des évaluations automatisées qui s'exécutent à chaque changement. Vous définissez les cas de test une fois et les exécutez contre n'importe quel modèle. Les résultats incluent les taux de réussite/échec, les comparaisons de coûts et les métriques de latence.

Qui utilise Promptfoo

Le projet compte 1,6 million de téléchargements npm et alimente des applications LLM servant plus de 10 millions d'utilisateurs finaux. Les entreprises l'utilisent pour :

• Chatbots de support client nécessitant des réponses cohérentes et précises
• Pipelines de génération de contenu qui doivent maintenir la voix de la marque
• Applications de santé et de fintech avec des exigences de conformité strictes
• Systèmes sensibles à la sécurité qui ne peuvent pas divulguer de données ou accepter des entrées nuisibles

En mars 2026, Promptfoo a rejoint OpenAI. Le projet reste open-source et sous licence MIT, avec un développement continu sous la nouvelle propriété.

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

Vous pouvez installer promptfoo globalement ou l'exécuter sans installation en utilisant npx.

Installation

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

# Ou exécuter sans installer
npx promptfoo@latest

# Les utilisateurs macOS peuvent également utiliser Homebrew
brew install promptfoo

# Les utilisateurs Python peuvent également utiliser pip
pip install promptfoo

Définissez vos clés API comme variables d'environnement :

export OPENAI_API_KEY=sk-abc123
export ANTHROPIC_API_KEY=sk-ant-xxx

Créer votre première évaluation

Initialisez un projet exemple :

promptfoo init --example getting-started
cd getting-started

Ceci crée un fichier promptfooconfig.yaml avec des prompts, des fournisseurs et des cas de test exemples.

Exécutez l'évaluation :

promptfoo eval

Affichez les résultats dans l'interface utilisateur web :

promptfoo view

L'interface utilisateur s'ouvre à localhost:3000 et affiche une comparaison côte à côte des sorties de chaque modèle, avec le statut de réussite/échec pour chaque assertion.

Comprendre le fichier de configuration

Le fichier promptfooconfig.yaml définit votre suite d'évaluations :

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

• prompts: Fichiers ou texte intégré à tester
• providers: Modèles à évaluer (prend en charge plus de 90 fournisseurs)
• tests: Cas de test avec variables et assertions

Vous pouvez étendre cela à des centaines de cas de test. De nombreuses équipes conservent les configurations d'évaluation sous contrôle de version et les exécutent en CI à chaque pull request.

Fonctionnalités principales : Ce que Promptfoo peut faire

1. Évaluations automatisées

Les évaluations automatisées sont le fondement de promptfoo. Vous définissez des cas de test avec des résultats attendus, et l'outil les exécute sur les modèles que vous avez choisis.

Types d'assertions

Promptfoo inclut plus de 30 types d'assertions intégrées :

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

Ce test vérifie que la réponse mentionne Paris, reste sous 100 caractères, répond en moins de 2 secondes et coûte moins de 0,001 $.

Évaluations notées par LLM

L'assertion llm-rubric utilise un LLM pour noter la sortie d'un autre. C'est puissant pour des critères subjectifs comme le ton ou l'utilité :

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

Le LLM évaluateur lit la sortie et la note par rapport à votre grille. Vous pouvez utiliser un modèle moins cher pour la notation afin de réduire les coûts.

2. Tests de sécurité et Red Teaming

Promptfoo inclut des tests de sécurité complets via son module red team. Il génère automatiquement des entrées adverses pour sonder les vulnérabilités.

Vecteurs d'attaque pris en charge

Le système red team inclut plus de 67 plugins organisés par catégorie :

Exécuter une analyse Red Team

Initialisez une configuration red team :

promptfoo redteam init

Exécutez l'analyse de sécurité :

promptfoo redteam run

Affichez le rapport :

promptfoo redteam report [directory]

La commande redteam run effectue deux étapes :

1. Génère des sondes d'attaque dynamiques adaptées à votre application
2. Évalue les sondes contre votre cible et note les vulnérabilités

Les résultats incluent des classifications de gravité (Critique, Élevé, Moyen, Faible), des cas de test exploitables et des recommandations de remédiation.

Exemple de sortie Red Team

Résumé des vulnérabilités :
- Critique : 2 (fuite d'informations personnelles identifiables (PII), extraction de prompt)
- Élevé : 5 (jailbreaks, attaques par injection)
- Moyen : 12 (biais, réponses incohérentes)
- Faible : 23 (violations mineures de politiques)

Résolvez les problèmes critiques avant le déploiement. Réexécutez les analyses après les modifications pour vérifier les correctifs.

3. Analyse de code pour les Pull Requests

Promptfoo s'intègre avec GitHub Actions pour analyser les pull requests à la recherche de problèmes de sécurité liés aux LLM.

# .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 }}

Ceci détecte :

• Clés API codées en dur dans les fichiers de configuration
• Modèles de prompts non sécurisés
• Validation d'entrée manquante
• Vecteurs potentiels d'injection de prompts

4. Comparaison de modèles

Comparez les sorties de plusieurs modèles côte à côte pour choisir le meilleur pour votre cas d'utilisation.

# Exécuter l'évaluation avec plusieurs fournisseurs
promptfoo eval

# Afficher la comparaison dans l'interface utilisateur web
promptfoo view

L'interface utilisateur web affiche :

• Taux de réussite/échec par modèle
• Coût par 1000 requêtes
• Latence moyenne
• Différences qualitatives de sortie

Cette approche basée sur les données prévient les biais envers les modèles familiers. Vous pourriez découvrir qu'un modèle moins cher surpasse GPT-4 sur vos évaluations spécifiques.

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

Promptfoo prend en charge plus de 90 fournisseurs LLM prêts à l'emploi. Vous pouvez tester le même prompt sur OpenAI, Anthropic, Google, Amazon et des modèles locaux sans modifier votre code.

Principaux fournisseurs

Fournisseurs personnalisés

Vous pouvez écrire des fournisseurs personnalisés en Python ou JavaScript si votre modèle n'est pas pris en charge.

Exemple 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
            }
        }

Exemple JavaScript :

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

Enregistrez les fournisseurs personnalisés dans votre configuration :

providers:
  - id: file://custom_provider.py
    config:
      api_key: ${MY_API_KEY}

Interface en ligne de commande : Commandes essentielles

L'interface en ligne de commande de Promptfoo fournit toutes les fonctionnalités dont vous avez besoin pour vos flux de travail quotidiens.

Commandes principales

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

# Ouvrir l'interface utilisateur web
promptfoo view

# Partager les résultats en ligne
promptfoo share

# Tests 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>

Options utiles

--no-cache              # Désactiver le cache pour des résultats frais
--max-concurrency <n>   # Limiter les appels API parallèles
--output <file>         # Écrire les résultats dans un fichier JSON
--verbose               # Activer la journalisation de débogage
--env-file <path>       # Charger les variables d'environnement à partir d'un fichier
--filter <pattern>      # Exécuter des cas de test spécifiques

Exemple : Exécuter une évaluation avec des paramètres personnalisés

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

Ceci exécute les évaluations à neuf (sans cache), limite la concurrence à 3 appels parallèles, enregistre les résultats au format JSON et charge les clés API à partir de .env.

Intégration CI/CD : Automatiser les tests LLM

Intégrez promptfoo dans votre pipeline CI/CD pour détecter les régressions avant le déploiement.

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 }}

Portes de qualité

Définissez des seuils de réussite/échec dans votre configuration :

commandLineOptions:
  threshold: 0.8  # Nécessite un taux de réussite de 80%

Ceci fait échouer la CI si les évaluations ne respectent pas le seuil, empêchant les régressions d'être fusionnées.

Mise en cache en CI

Activez la mise en cache pour accélérer les exécutions CI :

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

Les résultats mis en cache évitent les appels API pour les tests inchangés, réduisant ainsi le temps et les coûts de la CI.

Interface utilisateur Web : Visualiser et partager les résultats

L'interface utilisateur web intégrée (promptfoo view) offre une interface interactive pour l'examen des évaluations.

Fonctionnalités

• Matrice d'évaluation - Compare les sorties côte à côte
• Filtrage - Trouve des cas de test spécifiques par statut ou fournisseur
• Vue Diff - Voit exactement ce qui a changé entre les exécutions
• Partage - Génère des liens partageables pour l'examen par l'équipe
• Mises à jour en temps réel - Observe les évaluations s'exécuter en direct

Accès et sécurité

L'interface utilisateur s'exécute sur localhost:3000 par défaut. Elle inclut une protection CSRF utilisant les en-têtes Sec-Fetch-Site et Origin pour bloquer les requêtes intersites provenant d'origines non fiables.

N'exposez pas le serveur web local à des réseaux non fiables. Pour l'accès en équipe, utilisez la commande promptfoo share pour télécharger les résultats vers le cloud, ou auto-hébergez avec authentification.

Base de données et mise en cache

Emplacement du cache

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

Le cache stocke les résultats des évaluations pour accélérer les exécutions répétées. Utilisez --no-cache pendant le développement pour garantir des résultats frais.

Emplacement de la base de données

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

La base de données stocke les exécutions d'évaluations historiques pour la comparaison et l'analyse des tendances. Ne supprimez pas ce fichier à moins que vous ne vouliez perdre les données historiques.

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

Promptfoo fonctionne sur un modèle de confiance par configuration. Comprendre cela prévient les surprises en matière de sécurité.

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

Ces entrées s'exécutent comme du code et ne devraient provenir que de sources fiables :

• Fichiers de configuration (promptfooconfig.yaml)
• Assertions JavaScript/Python/Ruby personnalisées
• Configurations des fournisseurs
• Fonctions de transformation

Entrées non fiables (données uniquement)

Ces entrées sont traitées comme des données et ne devraient pas déclencher l'exécution de code :

• Texte du prompt
• Variables des cas de test
• Sorties du modèle
• Contenu distant récupéré pendant les évaluations

Recommandations de renforcement

Pour les environnements à haute sécurité :

1. Exécutez-vous à l'intérieur d'un conteneur ou d'une VM avec des privilèges minimaux
2. Utilisez des clés API dédiées et avec le moins de privilèges possible
3. Évitez de placer des secrets dans les prompts ou les fichiers de configuration
4. Restreignez la sortie réseau pour le code tiers
5. N'exposez pas le serveur web local à des réseaux non fiables

Performance : Optimiser vos évaluations

Conseils d'optimisation

1. Utilisez la mise en cache - Le comportement par défaut accélère les exécutions répétées
2. Ajustez la concurrence - --max-concurrency équilibre la vitesse et les limites de débit
3. Filtrez les tests - Utilisez --filter pour exécuter des cas de test spécifiques pendant le développement
4. Échantillonnez les jeux de données - Utilisez --repeat avec des sous-ensembles pour l'itération avant les exécutions complètes

Mise à l'échelle pour les grandes évaluations

Pour les évaluations à grande échelle avec des milliers de cas de test :

• Utilisez l'ordonnanceur (src/scheduler/) pour les exécutions distribuées
• Exploitez la génération à distance pour décharger le calcul
• Exportez les résultats vers Google Sheets pour la visibilité de l'équipe

Extensibilité : Construire des fonctionnalités personnalisées

Assertions personnalisées

Écrivez des assertions personnalisées pour des vérifications spécifiques à un domaine :

// 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'
  };
}

Utiliser dans votre configuration :

assert:
  - type: file://assertions/customCheck.js

Serveur MCP

Promptfoo inclut un serveur de protocole de contexte de modèle (MCP) pour l'intégration avec des assistants IA comme Claude Code :

promptfoo mcp

Ceci permet aux agents IA de :

• Exécuter des évaluations directement depuis le chat
• Accéder aux capacités de la red team
• Interroger les résultats stockés
• Générer de nouveaux cas de test

Cas d'utilisation réels

Chatbot de support client

Une entreprise SaaS utilise promptfoo pour tester son chatbot de support avant chaque déploiement :

• 500 cas de test couvrant les questions courantes
• Évaluation sur GPT-4 et Claude pour comparer la qualité
• Analyses red team pour les fuites de PII et les jailbreaks
• L'intégration CI bloque les déploiements avec des évaluations échouées

Résultat : Réduction de 90 % des problèmes signalés par les clients après la mise en œuvre d'évaluations automatisées.

Pipeline de génération de contenu

Une équipe marketing valide le contenu généré par l'IA pour la voix de la marque :

• Les évaluations notées par LLM vérifient le ton et le style
• Les seuils de latence garantissent une génération rapide
• La surveillance des coûts maintient les dépenses sous contrôle
• La comparaison des modèles trouve le meilleur fournisseur en termes de rapport qualité-prix

Résultat : Voix de marque cohérente sur tout le contenu avec 40 % de réduction des coûts d'API.

Application de santé

Une startup de technologie de la santé assure la conformité avec des tests stricts :

• Analyses red team pour les violations HIPAA
• Assertions personnalisées validant l'exactitude médicale
• Toutes les évaluations s'exécutent localement pour la confidentialité des données
• Pistes d'audit pour les exigences réglementaires

Résultat : Audit SOC 2 réussi avec les évaluations promptfoo comme preuve.

Conclusion

Promptfoo apporte des tests systématiques aux applications LLM. Il remplace les processus manuels et sujets aux erreurs par des évaluations automatisées qui détectent les régressions, les problèmes de sécurité et de qualité avant le déploiement.

Points clés à retenir :

• Installez avec npm install -g promptfoo et démarrez avec promptfoo init
• Utilisez des assertions pour valider les sorties au-delà de la correspondance exacte de chaînes
• Exécutez des analyses red team pour trouver des vulnérabilités de sécurité
• Intégrez avec CI/CD pour bloquer les régressions
• Comparez les modèles objectivement avec des évaluations côte à côte
• Les fournisseurs et assertions personnalisés étendent les fonctionnalités

L'avenir du développement de l'IA est axé sur les données. Avec promptfoo, vous disposez des outils pour construire, tester et sécuriser des applications LLM à grande échelle.

Si vous travaillez également avec des API, envisagez d'utiliser Apidog en parallèle de promptfoo. Apidog gère la conception, le test et la documentation des API, tandis que promptfoo se concentre sur l'évaluation des LLM. Ensemble, ils couvrent la pile complète des tests d'applications modernes.

FAQ

À quoi sert promptfoo ?

Promptfoo est utilisé pour tester et évaluer les applications LLM. Il exécute des tests automatisés sur les prompts, compare les sorties entre les modèles et effectue des évaluations de sécurité par des équipes rouges (red-team) pour trouver des vulnérabilités.

Promptfoo est-il gratuit ?

Oui, promptfoo est open-source et sous licence MIT. Vous pouvez l'utiliser gratuitement pour des projets personnels et commerciaux. Les fonctionnalités cloud et le support d'entreprise peuvent nécessiter des plans payants.

Comment installer promptfoo ?

Exécutez npm install -g promptfoo pour une installation globale. Vous pouvez également utiliser npx promptfoo@latest sans installer, ou installer via brew install promptfoo sur macOS ou pip install promptfoo pour Python.

Quels modèles promptfoo prend-il en charge ?

Promptfoo prend en charge plus de 90 fournisseurs LLM, y compris OpenAI (GPT-4, GPT-4o, o1), Anthropic (Claude 3.5/4/4.5), Google (Gemini), Microsoft (Azure OpenAI), Amazon Bedrock et les modèles locaux via Ollama.

Comment exécuter une analyse red team ?

Exécutez promptfoo redteam init pour créer une configuration, puis promptfoo redteam run pour exécuter l'analyse de sécurité. Affichez les résultats avec promptfoo redteam report.

Puis-je utiliser promptfoo en CI/CD ?

Oui. Installez promptfoo dans votre pipeline CI et exécutez promptfoo eval avec votre fichier de configuration. Définissez des portes de qualité avec l'option threshold pour faire échouer la CI si les évaluations ne respectent pas les taux de réussite.

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

Non. Promptfoo s'exécute 100 % localement par défaut. Vos prompts et vos données de test ne quittent jamais votre machine, sauf si vous choisissez explicitement d'utiliser les fonctionnalités cloud. Les fichiers de cache et de base de données sont stockés localement.

Comment comparer des modèles avec promptfoo ?

Listez plusieurs fournisseurs dans votre fichier de configuration, puis exécutez promptfoo eval. Affichez la comparaison dans l'interface utilisateur web avec promptfoo view, qui affiche les taux de réussite/échec, les coûts et la latence pour chaque modèle.