DSPy : l'outil qui écrit vos prompts à votre place (et les optimise)

POURQUOI LES PROMPTS DEVRAIENT ÊTRE AUTOMATISÉS

Quand on utilise une grande modèle de langage (LLM), on passe souvent des heures à reformuler un prompt pour obtenir la réponse souhaitée. On ajoute des exemples, on précise le ton, on explique le contexte… Mais dès qu’on intègre ce LLM dans une application qui tourne toute seule, ces ajustements manuels deviennent impossibles. Le prompt doit fonctionner du premier coup, à chaque fois, sans intervention humaine.

Imaginons une application qui analyse des documents pour en évaluer la plausibilité. Un prompt simple comme "Évalue la plausibilité du texte suivant : {document_text}" peut donner des résultats très variables. Parfois, l’IA se focalise sur des détails sans importance. D’autres fois, elle interprète mal le mot « plausible ». Résultat : des réponses inutiles, voire fausses. Pour éviter ça, il faut un prompt robuste, testé sur des dizaines de cas différents. Mais comment faire sans y passer des jours ?

DSPY, L'OUTIL QUI PREND LES RÊNES À VOTRE PLACE

DSPy est un outil Python qui automatise trois étapes cruciales : la création du prompt, son évaluation et son optimisation. Au lieu de perdre du temps à ajuster manuellement chaque phrase, DSPy génère des dizaines de versions de votre prompt, les teste sur vos données réelles, et garde la meilleure. Tout ça en quelques lignes de code.

Prenons l’exemple d’un LLM qui doit estimer la plausibilité d’un texte. DSPy commence par collecter un jeu de données de test : 20 ou 30 documents, chacun accompagné d’une note de plausibilité (par exemple, sur 10). Ensuite, il écrit un prompt, le teste sur ces documents, et compare les réponses de l’IA avec les notes réelles. Si la réponse est éloignée de la vérité, DSPy ajuste le prompt et recommence. Après des centaines d’itérations, il propose le prompt qui donne les meilleurs résultats.

Le code pour lancer ce processus ressemble à ceci :

import dspy

OPENAIAPIKEY = [indiquez votre clé API]
lm = dspy.LM("openai/gpt-4o-mini", apikey=OPENAIAPI_KEY)
dspy.settings.configure(lm=lm)

predictor = dspy.Predict("question, context -> answer, confidence")
prediction = predictor(question="What is the capital of France?", context="")
print(prediction.answer, prediction.confidence)

Ce code charge un modèle d’OpenAI (ici, gpt-4o-mini), configure DSPy pour l’utiliser, puis demande au LLM de répondre à une question simple. Le résultat ? Paris, High : la réponse est correcte, et l’IA est très confiante. Avec DSPy, on peut ensuite ajouter des étapes d’évaluation et d’optimisation pour des tâches bien plus complexes.

L'ÉVALUATION AUTOMATIQUE : LE SECRET POUR DES PROMPTS FIABLES

Tester un prompt manuellement, c’est comme goûter une soupe en remuant une seule fois avec une cuillère : on n’a pas une idée précise de son goût. Pour évaluer correctement un prompt, il faut le tester sur des dizaines de cas différents, et plusieurs fois pour chaque cas (car les LLM donnent des réponses aléatoires même avec le même prompt).

DSPy automatise cette évaluation avec une fonction Python qui note la qualité des réponses. Par exemple, pour notre tâche de plausibilité, cette fonction pourrait ressembler à :

def evaluateanswer(testinstance, model_prediction):
    return abs(testinstance.groundtruth - model_prediction)

Ici, ground_truth est la note réelle de plausibilité du document, et model_prediction est la note donnée par l’IA. Plus la différence entre les deux est petite, meilleure est la réponse. DSPy exécute cette fonction pour chaque test, puis calcule une note globale. Si le prompt obtient 8/10, c’est qu’il fonctionne bien. Si c’est 3/10, il faut le retravailler.

Cette méthode évite les biais humains : on ne se contente plus de « ça semble bon » ou « ça ne semble pas bon ». DSPy donne une note objective, reproductible, et surtout, comparable entre différents prompts.

LA BOUCLE D'OPTIMISATION : DSPY AMÉLIORE VOS PROMPTS TOUT SEUL

DSPy ne se contente pas d’évaluer vos prompts : il les améliore en continu. Imaginez un algorithme qui écrit des prompts, les teste, garde les meilleurs, et recommence avec des variantes plus prometteuses. C’est exactement ce que fait DSPy avec sa boucle d’optimisation.

Voici comment ça marche en pratique :

best_prompt = ""
loop
  generate a new candidate prompt
  evaluate this candidate prompt
  if this is the best prompt so far:
    best_prompt = current prompt

À chaque itération, DSPy génère un nouveau prompt (en utilisant une technique appelée meta-prompting, où un LLM écrit un prompt pour un autre LLM), l’évalue, et garde le meilleur. Plus la boucle tourne longtemps, plus les prompts deviennent précis. DSPy peut même arrêter prématurément les tests sur les prompts médiocres pour gagner du temps, tout en analysant en profondeur les meilleurs candidats.

Ce processus apprend en temps réel : DSPy identifie quels mots ou formulations fonctionnent bien sur certains types de documents, et les réutilise pour les prochains prompts. Résultat ? Des prompts de plus en plus efficaces, sans effort de votre part.

DSPY FACE À L'INGÉNIERIE DE PROMPTS TRADITIONNELLE

Avant DSPy, la méthode standard pour créer un prompt consistait à l’écrire, le tester sur quelques exemples, puis le réécrire si nécessaire. Problème : cette méthode est lente, peu fiable, et surtout, elle ne scale pas. Tester un prompt sur 20 documents, 3 fois chacun, ça fait 60 tests. Personne ne fait ça à la main. Résultat : on teste rarement assez, et on se retrouve avec des prompts qui marchent « à peu près » en Développement, mais qui échouent en production.

DSPy change la donne en automatisant ce processus. Comparons les deux approches :

Autre avantage : DSPy permet de tester plusieurs modèles de LLM en quelques minutes. Vous voulez savoir si gpt-4o-mini est meilleur que claude-3-haiku pour votre tâche ? Changez une ligne dans votre code, relancez l’optimisation, et comparez les scores. Aucune manipulation manuelle, aucune perte de temps.

DES CAS D'USAGE VARIÉS, DE L'E-MAIL AUX DOCUMENTS TECHNIQUES

DSPy n’est pas limité à un seul type de tâche. Il peut optimiser des prompts pour :

• Analyser des e-mails (détection de spam, résumé, extraction d’informations)
• Traduire des articles ou des brevets
• Générer des critiques de textes (comme dans notre exemple de plausibilité)
• Classer des documents par thème ou par sentiment
• Interagir avec des images, de l’audio ou d’autres types de données

Prenons l’exemple d’une application qui traite des e-mails. En production, les e-mails peuvent être très variés : trop longs, trop courts, ambigus, mal formulés… Un prompt classique pourrait ressembler à :

prompttext = f"Analyse cet e-mail et extrais les informations suivantes : {emailtext}"

Mais ce prompt peut échouer sur des e-mails complexes ou mal structurés. Avec DSPy, on peut tester ce prompt sur des centaines d’e-mails réels, ajuster les formulations, et obtenir un résultat fiable à 90%. Le gain de temps et de précision est énorme.

COMMENT DSPY ÉVALUE LES RÉPONSES LONGUES ?

Certaines tâches demandent aux LLM de générer des réponses longues : résumés, traductions, critiques détaillées… Évaluer ces réponses manuellement est fastidieux et subjectif. DSPy utilise alors une astuce : il fait appel à un autre LLM pour juger la qualité des réponses. C’est ce qu’on appelle l’évaluation par LLM-as-a-judge.

Par exemple, si votre application doit résumer un article, DSPy peut demander à un second LLM de comparer le résumé généré avec l’article original. Le juge attribue une note en fonction de la fidélité, de la clarté et de la concision. Cette méthode n’est pas parfaite (les LLM peuvent aussi se tromper), mais elle est bien plus rapide et objective qu’une évaluation humaine.

Cette approche permet de tester des dizaines de prompts en quelques heures, là où une évaluation manuelle prendrait des jours.

UN EXEMPLE CONCRET : OPTIMISER UN PROMPT POUR UNE TÂCHE DE CLASSIFICATION

Imaginons une application qui classe des textes en fonction de leur sentiment (positif, négatif, neutre). Un prompt simple pourrait être :

"Classe ce texte en positif, négatif ou neutre : {text}"

Mais ce prompt peut donner des résultats incohérents. Par exemple, un texte sarcastique pourrait être classé comme positif alors qu’il est négatif. Avec DSPy, on peut :

1. Collecter un jeu de données de 50 textes, chacun annoté avec le sentiment réel.
2. Écrire une fonction d’évaluation qui compare la réponse de l’IA avec l’annotation réelle.
3. Lancer l’optimisation de DSPy pour générer et tester des dizaines de prompts.

Résultat : après quelques heures, DSPy propose un prompt comme :

"Lis attentivement ce texte. Si le ton est clairement positif (mots comme 'génial', 'excellent'), réponds 'positif'. Si le ton est clairement négatif (mots comme 'horrible', 'mauvais'), réponds 'négatif'. Sinon, réponds 'neutre'. Texte : {text}"

Ce prompt est plus précis, plus robuste, et donne des résultats bien meilleurs que la version initiale.

DSPY CONTRE LES MÉTHODES MANUELLES : LE GRAND ÉCART

Pour bien comprendre l’avantage de DSPy, comparons-le à l’ingénierie de prompts traditionnelle :

Temps : Une optimisation manuelle peut prendre des heures, voire des jours. Avec DSPy, c’est une question de minutes ou d’heures, selon la complexité de la tâche.

Fiabilité : Un prompt testé sur 5 exemples ne garantit pas qu’il fonctionnera sur 1 000. DSPy teste sur des jeux de données représentatifs, ce qui réduit les risques d’échec en production.

Reproductibilité : Avec l’ingénierie manuelle, deux développeurs peuvent obtenir des résultats différents pour le même prompt. DSPy donne toujours le même résultat pour les mêmes données.

Flexibilité : Changer de modèle de LLM ? Avec DSPy, il suffit de modifier une ligne de code. Avec l’ingénierie manuelle, il faut tout recommencer.

LES LIMITES DE DSPY (ET COMMENT LES DÉPASSER)

DSPy n’est pas une baguette magique. Il a quelques limites :

• Nécessite des données de test : Pour évaluer un prompt, il faut un jeu de données annoté. Sans ça, DSPy ne peut pas fonctionner. Heureusement, créer un tel jeu est souvent plus simple que d’optimiser manuellement un prompt.
• Coût des appels API : DSPy exécute des centaines, voire des milliers d’appels à un LLM. Si vous utilisez un modèle payant comme gpt-4o-mini, cela peut coûter quelques euros. Mais c’est bien moins cher que de perdre des heures à ajuster manuellement un prompt.
• Complexité pour les tâches très spécifiques : Si votre tâche est ultra-niche, DSPy peut avoir du mal à générer des prompts pertinents. Dans ce cas, il faut souvent ajuster manuellement les prompts générés par DSPy.

Pour dépasser ces limites, voici quelques conseils :

• Commencez par un petit jeu de données (10-20 exemples) pour tester DSPy rapidement.
• Utilisez des modèles gratuits ou peu chers pour les premières optimisations.
• Ajoutez des exemples dans vos prompts pour guider DSPy (comme dans le few-shot prompting).

COMMENT INTÉGRER DSPY DANS UN PROJET EXISTANT

Intégrer DSPy dans un projet existant est simple. Voici les étapes à suivre :

1. Installez DSPy : pip install dspy.
2. Configurez votre LLM : Indiquez à DSPy quel modèle utiliser et fournissez votre clé API. DSPy supporte plus de 20 fournisseurs, dont OpenAI, Anthropic, Mistral et Hugging Face.
3. Définissez votre tâche : Spécifiez ce que le LLM doit faire (répondre à une question, classer un texte, etc.) et comment évaluer les réponses.
4. Lancez l’optimisation : DSPy génère des prompts, les teste, et garde les meilleurs. Vous pouvez ajuster le nombre d’itérations pour obtenir plus de précision ou gagner du temps.
5. Déployez le prompt optimisé : Une fois satisfait, utilisez le prompt dans votre application. DSPy fournit aussi des outils pour exporter le prompt dans un format utilisable par d’autres frameworks.

Voici un exemple complet pour une tâche de classification de sentiment :

import dspy

# Configurez le LLM
lm = dspy.LM(model="openai/gpt-4o-mini", apikey="votreclé_api")
dspy.settings.configure(lm=lm)

# Définissez votre tâche
class ClassifySentiment(dspy.Module):
    def __init__(self):
        super().__init__()
        self.predictor = dspy.Predict("text -> sentiment")

    def forward(self, text):
        return self.predictor(text=text)

# Optimisez le prompt
optimizer = dspy.optimizers.BootstrapFewShot(
    metric=lambda example, pred, trace:
        1 if pred.sentiment == example.sentiment else 0,
    maxbootstrappeddemos=4,
)
compiled = optimizer.compile(ClassifySentiment())

# Testez le prompt optimisé
result = compiled(text="Ce film était incroyable .")
print(result.sentiment)  # Devrait afficher "positif"

DSPY POUR LES DÉBUTANTS : PAR OÙ COMMENCER

Si vous débutez avec DSPy, voici une marche à suivre simple :

1. Lisez la documentation : DSPy est bien documenté, avec des tutoriels pour les débutants. Le livre Building LLM Applications with DSPy (co-écrit par l’auteur de l’article) est une excellente ressource.
2. Commencez par une tâche simple : Essayez d’optimiser un prompt pour une classification binaire (par exemple, détecter si un texte est positif ou négatif).
3. Utilisez des données réelles : Plus vos données de test sont représentatives de la réalité, plus le prompt optimisé sera fiable.
4. Expérimentez avec les paramètres : DSPy offre plusieurs options pour l’optimisation (nombre d’itérations, modèles utilisés, etc.). Testez-les pour voir ce qui fonctionne le mieux pour votre cas.

Un bon premier projet pourrait être d’optimiser un prompt pour résumer des articles de news. Avec DSPy, vous pourrez générer un prompt qui produit des résumés clairs et concis, sans avoir à ajuster manuellement chaque phrase.

LES ALTERNATIVES À DSPY : EXISTENT-ELLLES ?

DSPy n’est pas le seul outil du genre. D’autres frameworks proposent des fonctionnalités similaires, mais avec des approches différentes :

• LangChain : Permet de créer des chaînes de traitement pour les LLM, mais ne gère pas l’optimisation automatique des prompts.
• LlamaIndex : Se concentre sur l’indexation et la récupération de données, pas sur l’optimisation des prompts.
• Promptfoo : Outil open-source pour tester et comparer des prompts, mais sans génération automatique.
• Automatic Prompt Engineer (APE) : Utilise aussi des LLM pour générer et optimiser des prompts, mais avec une approche moins intégrée que DSPy.

DSPy se distingue par sa simplicité, son intégration complète (création, évaluation et optimisation) et sa flexibilité. C’est pourquoi il est considéré comme l’un des outils les plus avancés dans ce domaine.

DSPY ET L'AVENIR DE L'INGÉNIERIE DE PROMPTS

DSPy représente une évolution majeure dans la façon dont on travaille avec les LLM. Au lieu de passer des heures à ajuster des prompts manuellement, on peut désormais automatiser ce processus et obtenir des résultats bien plus fiables. Cette approche est particulièrement utile pour les applications en production, où la robustesse est cruciale.

À l’avenir, on peut imaginer que des outils comme DSPy deviendront la norme pour toute application basée sur des LLM. Les développeurs n’auront plus à se soucier des prompts : ils écriront du code pour définir leurs tâches, et DSPy s’occupera du reste. Cela libérera du temps pour se concentrer sur l’innovation, plutôt que sur des ajustements fastidieux.

Un autre avantage est la démocratisation de l’IA. Aujourd’hui, seuls les experts en prompt engineering peuvent créer des applications performantes avec des LLM. Avec DSPy, même un débutant peut obtenir des résultats professionnels en quelques lignes de code.

CONCLUSION : ET SI VOUS LAISSIEZ DSPY ÉCRIRE VOS PROMPTS ?

Les prompts sont le nerf de la guerre pour les applications basées sur des LLM. Un bon prompt peut faire la différence entre une application qui fonctionne et une qui échoue. Pourtant, les méthodes traditionnelles pour créer ces prompts sont lentes, peu fiables et peu scalables.

DSPy change la donne en automatisant la création, l’évaluation et l’optimisation des prompts. Grâce à lui, vous pouvez obtenir des prompts robustes et fiables en quelques heures, sans avoir à passer des jours à ajuster manuellement chaque phrase. Que vous travailliez sur une application de classification, de résumé, de traduction ou d’analyse de texte, DSPy peut vous faire gagner un temps précieux et améliorer la qualité de vos résultats.

Si vous utilisez des LLM dans vos projets, DSPy est un outil à essayer absolument. Il représente l’avenir de l’ingénierie de prompts : automatisé, fiable et accessible à tous.

CE QU'IL FAUT RETENIR

• DSPy automatise la création, l’évaluation et l’optimisation des prompts pour les LLM.
• Il génère des dizaines de versions d’un prompt, les teste sur vos données, et garde la meilleure.
• L’évaluation automatique évite les biais humains et donne des résultats objectifs.
• DSPy permet de tester plusieurs modèles de LLM en quelques minutes.
• Il est particulièrement utile pour les applications en production, où la robustesse est cruciale.
• Les alternatives existent, mais DSPy est l’un des outils les plus avancés et flexibles.

Alors, prêt à laisser DSPy écrire vos prompts à votre place ?