Depuis des années, créer des applications alimentées par des modèles de langage larges (LLM) ressemblait à naviguer dans un paysage brumeux. Les développeurs passaient d'innombrables heures à affiner manuellement les invites (prompts), ajuster les paramètres de température et expérimenter avec des exemples à few-shot, espérant obtenir cette amélioration de précision de 1 % si elusive. Cette approche manuelle, souvent appelée « ingénierie d'invite » (prompt engineering), est fragile, non déterministe et difficile à mettre à l'échelle.
Voici l'Ingénierie IA déclarative et DSPy (Demanding, Simple, Pythonic). Développé par le groupe NLP de Stanford, DSPy représente un changement de paradigme fondamental. Il considère l'utilisation des LLM non pas comme une chaîne de texte statique, mais comme un flux de travail programmatique qui peut être automatiquement optimisé par le compilateur lui-même. Dans cet article, nous explorerons comment DSPy permet aux développeurs de définir ce que le système IA doit faire, tandis que le framework détermine comment le faire au mieux.
Le problème de l'invite impérative
Dans l'intégration traditionnelle des LLM, le code ressemble à ceci :
response = llm.generate(
prompt="Répondez à la question suivante : " + question,
temperature=0.7
)
Bien que simple, cette approche manque de structure. Si vous souhaitez effectuer un raisonnement multi-étapes, vous devez enchaîner manuellement ces appels, écrire une logique de validation pour vérifier les étapes intermédiaires et ajuster manuellement les invites en fonction de l'analyse des erreurs. Il s'agit d'une approche impérative : vous dictez chaque étape. À mesure que la complexité augmente, la charge de maintenance augmente également.
Programmation déclarative avec DSPy
DSPy inverse ce modèle. Au lieu d'écrire des invites, vous écrivez des signatures — des instructions déclaratives qui définissent l'entrée et la sortie d'une étape. DSPy compile ensuite ces signatures en invites optimisées de manière dynamique.
Considérons une tâche simple de Question-Réponse (QA). Dans DSPy, vous définissez une signature GenerateAnswer :
import dspy
class GenerateAnswer(dspy.Signature):
"""Répondez aux questions avec des réponses factuelles courtes."""
context = dspy.InputField()
question = dspy.InputField()
answer = dspy.OutputField()
Remarquez qu'il n'y a pas de mots spécifiques ici indiquant au LLM comment formuler son processus de pensée. Vous déclarez simplement les types de données. DSPy gère la partie répétitive (boilerplate) consistant à formater ces champs en une invite efficace pour le modèle sous-jacent.
La magie de la compilation : Optimisation programmatique
La véritable puissance de DSPy réside dans son optimiseur. Dans l'ingénierie traditionnelle, vous pourriez écrire un script pour tester différentes variations d'invite (tests A/B). Dans DSPy, vous fournissez un formateur (trainer) et une métrique, et le framework recherche automatiquement la meilleure stratégie d'invite.
Regardons un exemple pratique utilisant l'optimiseur BootstrapFewShot. Tout d'abord, nous définissons notre module :
class QA(dspy.Module):
def __init__(self):
super().__init__()
self.prog = dspy.ChainOfThought(GenerateAnswer)
def forward(self, context, question):
return self.prog(context=context, question=question)
Ensuite, nous définissons une métrique pour évaluer le succès :
def metric_gold(context, question, answer, gold, trace=None):
return answer.strip().lower() == gold.strip().lower()
Enfin, nous compilons notre module. DSPy prendra un petit ensemble de données de démonstration, le fera passer par le LLM et générera automatiquement les meilleurs exemples few-shot et la structure d'invite pour maximiser votre métrique. Il « apprend » efficacement la meilleure façon d'inviter le modèle pour votre tâche spécifique.
optimizer = dspy.BootstrapFewShot(metric=metric_gold)
qa_optimized = optimizer.compile(QA(), trainset=train_data)
Pourquoi cela importe pour les frameworks d'agents
Alors que nous nous dirigeons vers des agents autonomes complexes, l'ingénierie d'invite manuelle devient impossible. Les agents nécessitent une planification robuste, l'utilisation d'outils et l'auto-réflexion. DSPy fournit l'infrastructure pour construire ces agents de manière déclarative. En optimisant la robustesse et la précision de manière programmatique, les développeurs peuvent créer des systèmes qui sont non seulement plus intelligents, mais aussi plus maintenables et reproductibles.
Conclusion
L'ingénierie IA déclarative avec DSPy n'est pas seulement un outil ; c'est une nouvelle façon de penser le développement logiciel avec les LLM. En passant de l'écriture d'invites à la définition de spécifications et à l'optimisation des métriques, les développeurs peuvent débloquer une fiabilité et des performances supérieures. Pour les développeurs intermédiaires à avancés prêts à aller au-delà de l'injection d'invite de base, DSPy offre une voie robuste et pythonique vers l'avenir dans le paysage en évolution rapide de l'ingénierie IA.