Aller au contenu principal
Dernière mise à jour le

Cycle de vie du développement de l'agent

Ce guide constitue un point de départ pour comprendre le cycle de vie complet de la création d'une application d'IA ou d'un agent d'IA. Tout au long de ce guide, « agent IA » est un terme générique désignant les systèmes alimentés par l'IA générative, y compris les appels LLM simples, les fonctions IA et les implémentations basées sur des agents.

Présentation du cycle de vie du développement​

  1. Comprendre le cas d'utilisation, la portée et les indicateurs de réussite
  2. Créer un agent IA initial
  3. Itérer sur la qualité des agents IA
  4. Alignez-vous avec les parties prenantes avant la production.
  5. Mettre en production et surveiller la qualité en continu

1. Comprendre le cas d'utilisation, la portée et les métriques de succès​

Avant de construire quoi que ce soit, clarifiez ce que l’agent IA est censé faire. Aligner avec les parties prenantes, y compris les personnes qui approuveront le déploiement en production.

  • Quels types d’entrées l’agent traitera-t-il (le « domaine » ou la « portée ») ? Quels utilisateurs soumettront les entrées ?
  • Comment l'agent devrait-il idéalement répondre aux entrées courantes ? Quelles informations ou quel contexte doit-il utiliser ?
  • Quels critères définissent une bonne ou une mauvaise réponse : ton, précision, exhaustivité, longueur de la réponse, sécurité, citations ou autres exigences ?
  • Quelles sont les exigences et contraintes du système en production : coût, latence et évolutivité ?
  • Quels sont les modes de défaillance potentiels et comment l'agent doit-il les gérer : mauvaises entrées utilisateur, informations insuffisantes pour répondre, commentaires utilisateur indiquant une mauvaise réponse, ou autres ?

Choisissez l'approche viable la plus simple. De nombreux cas d'utilisation ne nécessitent pas de systèmes agentiels ou multi-agents complexes. Avant de créer, évaluez où se situe votre problème sur le continuum de complexité. Une logique déterministe simple ou des fonctions d'IA batch suffiront-elles ? Si l'appel d'outils dynamique, le raisonnement ou la coordination sont nécessaires, alors envisagez les agents d'appel d'outils ou les systèmes multi-agents. Pour des conseils plus approfondis, consultez les modèles de conception de systèmes d'agents.

Cette fondation vous permet de :

  1. Identifiez les sources de données et les outils dont votre agent aura besoin
  2. Rédigez les instructions initiales ou les prompts qui reflètent le comportement attendu
  3. Identifiez les experts du domaine ou les testeurs qui peuvent fournir des exemples représentatifs et des retours préliminaires
  4. Créez des juges automatisés qui encodent les critères d'évaluation et accélèrent l'itération

Vous n'avez pas besoin d'une clarté parfaite à ce stade, et votre compréhension s'améliorera au fur et à mesure que vous itérerez. Mais un alignement plus solide dès le début, notamment sur la manière dont la qualité sera mesurée et ce que signifie « prêt pour la production », accélère considérablement les améliorations de qualité et la validation ultérieures.

2. Créez un agent IA initial​

Une fois votre cas d'utilisation et vos objectifs bien définis, vous êtes prêt à prototyper votre agent IA. Databricks propose à la fois des itinéraires guidés basés sur l'interface utilisateur et des itinéraires entièrement personnalisés basés sur le code pour la création d'agents IA.

2.1. Préparez les données et les outils​

Les agents IA utilisent généralement des données et des outils pour fournir du contexte et des capacités. Consultez Connecter les agents aux outils pour un aperçu de l'utilisation des données et des outils sur Databricks.

Recherchez les données et outils existants avant d'en créer de nouveaux :

  • Explorez les données disponibles dans Unity Catalog ou via la recherche du workspace pour comprendre quels actifs régis existent déjà. Cela vous aide à comprendre quel contexte et quelles capacités sont disponibles avant de créer de nouveaux assets.
  • Dans AI Playground, vous pouvez afficher et sélectionner les outils déjà disponibles pour les agents, tels que les index de recherche IA, les serveurs MCP ou les fonctions UC.

Créez et gérez de nouveaux actifs au besoin :

Tous ces data assets et outils sont régis et versionnés dans Unity Catalog, ce qui les rend découvrables et réutilisables par les agents et les applications d'IA.

2.2. Créez un agent initial.​

Avant de créer un agent personnalisé, vérifiez si un agent déclaratif Knowledge Assistant, des fonctions d'IA, ou un accélérateur de Solutions Databricks existant correspond déjà à votre cas d'utilisation. Pour les modèles courants, ces approches guidées peuvent réduire considérablement la configuration, améliorer la qualité default et accélérer le délai de mise en production.

Si un agent personnalisé est toujours requis, les nouveaux créateurs devraient start par la méthode la plus rapide pour expérimenter. Utilisez AI Playground pour prototyper un agent sans écrire de code. AI Playground vous permet d'essayer différents modèles, de faire de l'ingénierie de prompt et de tester des outils afin de comprendre rapidement la qualité des données, le comportement des agents et le potentiel de votre approche. Vous pouvez ensuite exporter l'agent sous forme de code pour une personnalisation et une itération plus poussées.

Si vous disposez déjà d'un code d'agent, vous pouvez l'importer dans Databricks et le déployer en tant qu'application Databricks.

Lorsque vous développez votre agent, planifiez à l'avance l'évaluation et la production :

  • Instrumentez votre agent avec MLflow Tracing pour enregistrer et analyser le comportement de l'agent.

    • À ce stade, concentrez-vous sur l’exactitude fonctionnelle : assurez-vous que l’agent s’exécute de bout en bout et peut accéder aux données et outils requis.
    • Vérification préliminaire pour les problèmes précoces tels qu'une mauvaise sélection d'outil, un contexte manquant ou des hallucinations.
    • Plus tard, ces traces seront utilisées pour évaluer la qualité de l'agent.

  • Lors de l'implémentation, tenez compte de la bonne méthode d'authentification pour votre application de production.

3. Itérer sur la qualité des agents IA​

Après l'existence d'un prototype fonctionnel, la phase suivante est une boucle étroite de mesure, de compréhension et d'amélioration de la qualité. Databricks place MLflow Evaluation au centre de cette boucle, avec le soutien de MLflow Tracing, des datasets d’évaluation et des juges LLM.

Les évaluateurs automatisés et les juges LLM assurent l'évolutivité et la cohérence, mais le feedback humain est essentiel pour valider l'utilité dans le monde réel et comprendre les défaillances subtiles. Les retours humains guident également le développement et l'étalonnage des juges LLM. Le feedback humain intervient généralement en trois étapes à mesure que l'agent mûrit :

  1. Validation précoce des développeurs et des parties prenantes
  2. Examen par des experts du domaine plus larges
  3. Commentaires des utilisateurs finaux

3.1. Valider le comportement en amont​

Les développeurs et un petit groupe de parties prenantes ou d'experts du domaine peuvent fournir des commentaires rapides et précoces. Avant de procéder à la mise à l'échelle des tests et de l'évaluation, assurez-vous que l'agent fait ce qu'il faut dans les situations les plus évidentes.

Pendant le prototypage, les développeurs effectuent souvent une « vérification informelle » en interrogeant manuellement l'agent pour confirmer qu'il fonctionne de bout en bout et se comporte comme prévu. Avec l'interface utilisateur de MLflow Tracing, les développeurs peuvent joindre des commentaires ou des attentes directement aux traces pour signaler les problèmes de qualité, marquer les exemples réussis et capturer des notes pour une évaluation et une itération futures.

Après le déploiement d'un prototype interne, l'interface utilisateur de discussion de l'application d'évaluation fournit une interface utilisateur simple pour recueillir des commentaires. Partagez l’interface utilisateur du chat de votre prototype avec un petit groupe de développeurs ou d’experts du domaine qui peuvent poser des requêtes à la fois raisonnables et problématiques.

MLflow Tracing enregistre les interactions et les retours d'information pour créer un dataset initial de résultats. Analysez les traces avec l'interface utilisateur MLflow ou le code pour comprendre les performances et le comportement de l'agent. Si les résultats sont mauvais ou inattendus, utilisez les traces pour déboguer :

  • Analysez les problèmes de qualité chez l'agent, tels que la mauvaise utilisation des outils, les hallucinations ou le contexte manquant. Appliquer les correctifs, tels que l'ajustement du prompt, l'utilisation d'outils ou les données. Voir 3.4. Corriger les problèmes et revérifier les améliorations.
  • À mesure que vous itérez, vous pouvez utiliser le dataset de trace comme entrées utilisateur représentatives pour générer des traces pour votre nouveau prototype.
  • Répétez cette boucle : exécutez, inspectez, corrigez et relancez, jusqu’à ce que l’agent gère la plupart ou la totalité des entrées représentatives comme prévu.
  • D'autres problèmes pourraient être découverts et traités lors d'itérations ultérieures. L'amélioration de la qualité est itérative et ne se limite pas à cette première phase.

Après cette étape, vous pouvez avoir la certitude que le prototype se comporte de manière pertinente dans les cas courants et atteint un niveau de qualité raisonnable, avant d’investir dans des tests plus approfondis.

3.2. Développer les tests et les retours​

Une fois que le prototype fonctionne dans des cas simples, montez en charge l'évaluation de la qualité en élargissant votre ensemble de bêta-testeurs et en recueillant des retours plus personnalisés. Cette phase révèle des angles morts tels que des sujets inattendus, des queries mal comprises, des lacunes dans les outils et la récupération ou des modèles d'utilisation émergents. Cela étend également vos jeux de données d'évaluation.

  • Déployez l'application auprès d'un plus large éventail de parties prenantes et d'experts du domaine, ou auprès d'utilisateurs finaux bêta. Intégrez leurs commentaires à mesure que l'agent est exposé à des modèles d'utilisation plus larges.
  • Capturez des commentaires et des attentes plus détaillés à l'aide de sessions d'étiquetage de l'application de révision avec un schéma personnalisé pour les commentaires d'experts.
  • Créez des jeux de données d’évaluation en synchronisant les retours humains et les traces étiquetées, en vue d’une évaluation et d’un monitoring systématiques à l’étape suivante.
  • Pour enrichir davantage le dataset d'évaluation, envisagez de générer des ensembles d'évaluation synthétiques.

3.3. Évaluer la qualité et déboguer systématiquement​

À mesure que vos datasets d’évaluation deviennent plus grands et plus diversifiés, vous aurez besoin de moyens structurés et plus automatisés pour détecter les problèmes, faire apparaître les défaillances les plus importantes et comprendre les causes profondes.

En pratique, vous diviserez probablement vos données en deux types de datasets d’évaluation :

  • Tests de régression : Les données avec des réponses d'IA de haute qualité aident à définir le comportement attendu. Utilisez ces datasets pour valider que les nouvelles versions de l’agent continuent de fonctionner correctement dans un ensemble large et diversifié de scénarios attendus.
  • debugging axé sur les problèmes : Les données avec des réponses d'IA de faible qualité peuvent inclure une variété de comportements indésirables. Isolez les groupes de traces qui présentent les mêmes types de comportement de faible qualité afin de comprendre les causes profondes et d'itérer sur des correctifs ciblés.

Les outils ci-dessous aident à créer et à analyser les deux types de datasets d'évaluation.

Exécuter des tests de régression​

  • Créez des tests de régression en sélectionnant des sous-ensembles de données représentatifs pour lesquels vous disposez de réponses d'IA de haute qualité ou d'attentes humaines.
  • Définir les critères d'évaluation à l'aide de juges et évaluateurs LLM intégrés ou personnalisés. L'évaluation automatisée peut utiliser des LLM seuls pour évaluer la qualité des réponses, ou comparer les réponses aux réponses de vérité terrain ou aux attentes.
  • Exécutez l'évaluation sur de nouvelles versions de votre agent afin de garantir que les mises à jour ne dégradent pas le comportement précédemment satisfaisant.

Identifiez les types de réponses de faible qualité.​

Améliorez la précision de la détection automatisée​

Bien que vous puissiez commencer à créer des jeux de données d'évaluation en utilisant principalement des commentaires humains, vous pouvez monter en charge l'évaluation avec la détection automatisée. Au fur et à mesure que vous itérez, investissez dans des juges LLM ou des évaluateurs basés sur du code adaptés à votre application et à votre domaine.

  • Commencez par les juges intégrés, et ajoutez des juges personnalisés et des scoreurs basés sur le code selon les besoins. Lorsque vous observez un mode de défaillance non détecté par un juge intégré, vous pouvez automatiser la détection future avec un juge ou un scoreur personnalisé conçu pour détecter ce type de défaillance spécifique.
  • Utilisez le feedback humain pour aligner les juges personnalisés sur les connaissances d'experts. L'ajustement des juges pour réduire les faux positifs et les faux négatifs augmentera la confiance dans l'évaluation et le triage automatisés.
  • Vos nouveaux juges et évaluateurs peuvent être utilisés à la fois pour l'évaluation automatisée et le monitoring, et pour le filtrage des traces afin de créer des datasets pour le debugging.

Traiter efficacement les problèmes de cause profonde​

Une fois une défaillance identifiée, vous devez déterminer la cause.

  • Utilisez MLflow Tracing pour inspecter manuellement chaque étape du raisonnement de l’agent :

    • Quels outils ont été sélectionnés
    • Comment les entrées et les sorties de l'outil ont été utilisées
    • Si la récupération a renvoyé un contexte pertinent
    • Comment les réponses du modèle ont influencé les décisions en aval

  • Appliquez MLflow AI Insights ou agent-as-a-judge pour analyser les traces et identifier les causes probables telles qu'un ancrage faible, une mauvaise structure d'invite ou des arguments d'outil incorrects.

  • Comparez les versions dans l'interface utilisateur d'évaluation de MLflow pour voir si les problèmes régressent ou persistent au fil des itérations.

Le résultat idéal de cette étape est d'avoir une compréhension structurée de ce qui échoue, des raisons de cet échec et de la manière d'y remédier. L'automatisation et les juges spécifiques aux applications vous permettent d'itérer en toute confiance à mesure que votre agent devient plus performant et que le jeu de tests devient plus complexe.

3.4. Corriger les problèmes et revérifier les améliorations​

Tout comme les problèmes sont spécifiques aux applications, les correctifs doivent être adaptés à votre application. Les exemples de correctifs courants incluent :

  • Optimisation des prompts : affinez les instructions de l’agent manuellement ou utilisez l’ optimisation des prompts data-driven. Pour une optimisation plus large de l’agent, telle que le réglage du raisonnement multi-étapes ou l’utilisation d’outils, utilisez le réglage DSPy.
  • Outils et données : Améliorez les outils ou les flux de récupération lorsque les traces révèlent des faits manquants ou un ancrage insuffisant.
  • Routage : Lorsque les traces indiquent que les mauvais outils ou sous-agents ont été appelés, améliorez les métadonnées de l'outil ou de l'agent, les invites ou le modèle de routage.
  • Garde-fous : Lorsque les réponses enfreignent les règles de sécurité ou divulguent des informations, utilisez soit les garde-fous AI Gateway, soit des garde-fous personnalisés dans votre agent.
  • Fallbacks : Gérez les cas extrêmes, les données manquantes ou les échecs d’appels API de manière appropriée à l’aide de mécanismes de fallback tels que des Endpoint API alternatifs ou des réponses de fallback.

Lorsque vous itérez sur les corrections, utilisez le Registre des invites pour enregistrer les versions afin de simplifier les comparaisons et les tests de régression.

Chaque correction apportée aux invites, à la récupération, aux outils, aux données ou à d’autres parties de votre agent doit être validée de la même manière qu’elle a été découverte. Réexécutez la nouvelle version de l'agent sur les mêmes datasets d'évaluation pour confirmer que le problème est corrigé et qu'aucune régression n'a été introduite.

4. S'aligner avec les parties prenantes avant la production​

Avant de déployer un agent dans un environnement réel, les équipes ont besoin d'une compréhension commune de ses capacités actuelles, de ses limites et de sa qualité mesurée. Atteindre ce point nécessite généralement plusieurs cycles d'itération et d'amélioration de la qualité à l'Étape 3. À ce stade, traduisez les signaux techniques (tels que les métriques d'évaluation, les métriques système et les exemples de traces) dans le contexte commercial qui détermine finalement si l'agent est véritablement « prêt ».

  • Traduisez les résultats d’évaluation en signaux commerciaux clairs : résumez la précision, la stabilité, la sécurité et les limites connues dans un langage sur lequel les parties prenantes peuvent agir.
  • Confirmez que les contrôles de qualité standardisés sont respectés : Assurez-vous que les métriques d'évaluation requises, les contrôles de régression et les seuils de couverture des datasets passent pour la version candidate.
  • Validez la préparation opérationnelle et obtenez l'approbation : passez en revue la configuration du monitoring, les garde-fous et le plan de déploiement. Documenter les risques et les critères d’acceptation avant la production.

5. Mettre en production et superviser la qualité en continu.​

Atteindre la production est une étape majeure ! Cela signifie que l'agent est prêt pour les utilisateurs réels et un impact réel. En même temps, la production est aussi le début d'un nouveau cycle. Une fois qu'un agent est opérationnel, il entre dans un cycle continu de monitoring et d'amélioration, car l'utilisation réelle fera apparaître de nouveaux comportements, des cas limites et des problèmes.

  • Recueillez le feedback des utilisateurs finaux en production. Link le feedback utilisateur à des traces spécifiques afin qu'il puisse être analysé en même temps que le comportement du modèle. Vous pouvez le faire en enregistrant les retours d'information sous forme d'évaluations jointes à la trace originale.

  • Tirez parti d’ AI Gateway pour les garde-fous, le routage et la journalisation cohérente. Assurez-vous que chaque nouvelle version de l’agent peut être évaluée par rapport au trafic réel sans friction opérationnelle.

  • Surveiller la qualité du trafic en direct en exécutant une évaluation sur des traces de production échantillonnées. Confirmez que la nouvelle version fonctionne au moins aussi bien que les versions précédentes, et recherchez les nouveaux problèmes à mesure que les utilisateurs soumettent de nouveaux types de requêtes. Le monitoring continu assure la fiabilité, la sécurité et l'alignement de l'agent avec les besoins de l'entreprise à mesure qu'il évolue. MLflow fournit un tableau de bord de monitoring, mais comme les traces peuvent être stockées dans Unity Catalog, vous pouvez personnaliser les tableaux de bord et les alertes :

  • Agissez sur les insights de production :

    • Pour les cas d’utilisation à risque élevé, link le monitoring à des mécanismes de rollback automatisés ou contrôlés pour corriger les problèmes critiques.
    • Utilisez vos insights de production dans votre prochaine itération. Convertissez les échecs réels en nouvelles données d'évaluation, et retournez à la boucle d'évaluation et de debugging pour construire la prochaine et meilleure version de votre agent.

Ressources supplémentaires​

Sur cette page