Introduction

Un flux de travail est une liste d’étapes exécutées dans l’ordre. Certaines étapes récupèrent ou lisent des choses, d’autres demandent à un modèle de les traiter, et d’autres encore enregistrent le résultat ou vous en informent. Chaque étape peut utiliser ce que les précédentes ont produit, et vous pouvez exécuter toute la liste à la main, selon un horaire, ou chaque fois qu’un flux ou un dossier reçoit quelque chose de nouveau.

Dans ce tutoriel, vous allez créer un flux de travail qui surveille les versions d’un outil dont vous dépendez. L’exemple utilise uv, le gestionnaire de paquets Python, parce qu’il publie souvent et que ses notes de version sont détaillées. Pour chaque nouvelle version, le flux de travail lit les notes de version, demande un court résumé à un modèle peu coûteux, enregistre ce résumé, et ne vous envoie une notification sur le bureau que si la version comporte des changements incompatibles. Vous allez le tester sans risque, lire ce qu’a fait chaque étape, corriger une étape sans tout relancer, puis l’approuver pour qu’il s’exécute seul.

Vous pouvez suivre ce tutoriel avec n’importe quel projet sur GitHub ; seule l’adresse du flux change.

L’essentiel

• Un flux de travail peut démarrer à la main, selon un horaire (tous les jours, en semaine ou toutes les quelques heures), ou quand un nouvel article apparaît dans un flux RSS ou Atom ou qu’un nouveau fichier arrive dans un dossier.
• Les étapes se transmettent leurs résultats grâce à des valeurs que vous insérez depuis un menu, comme le lien de l’article ou le texte produit par une étape précédente.
• Chaque étape qui utilise un modèle peut choisir le sien : le travail de routine peut donc aller à un modèle rapide et peu coûteux.
• Une étape Continuer seulement si… met fin à une exécution sans bruit quand il n’y a rien qui mérite votre attention.
• Avant qu’un flux de travail s’exécute seul, il liste tout ce qu’il aura le droit de faire, et vous approuvez cette liste. Tout ce qui sort de la liste met l’exécution en pause et vous demande.
• Chaque exécution enregistre ce que chaque étape a fait, et vous pouvez relancer à partir de n’importe quelle étape sans répéter les précédentes.
• Le même flux de travail peut se dessiner en canevas, se brancher selon une condition, exécuter des étapes côte à côte et confier du travail à des agents qui demandent avant d’agir.

Prérequis

Pour suivre ce tutoriel, vous aurez besoin de ce qui suit :

• Conduit installé sur Windows, macOS ou Linux. Téléchargez la dernière version depuis la page des versions.
• Un fournisseur de modèles configuré dans Conduit avec votre propre clé API. Ce tutoriel utilise GLM 5.3 Flash via OpenRouter pour les résumés, mais n’importe quel fournisseur convient, y compris un modèle local. Pour en configurer un, suivez l’un des guides des fournisseurs (en anglais), par exemple Use OpenRouter in a desktop app (en anglais).
• Les notifications du bureau autorisées pour Conduit dans les réglages de votre système d’exploitation, afin de voir les alertes envoyées par le flux de travail.
• (Facultatif) L’adresse d’un flux qui vous intéresse. Chaque dépôt GitHub publie ses versions sous forme de flux Atom à l’adresse https://github.com/<owner>/<repo>/releases.atom.

Étape 1 — Partir d’un flux de travail prêt à l’emploi

Conduit propose des flux de travail prêts à l’emploi, que vous pouvez utiliser tels quels ou modifier. Dans cette étape, vous allez en créer un qui surveille déjà un flux, et vous en servirez de base pour le suivi des versions.

Choisissez Flux de travail dans la barre latérale, ou appuyez sur Ctrl+6 (⌘6 sur macOS). Si vous n’avez encore aucun flux de travail, la page liste les modèles prêts à l’emploi sous Aucun flux de travail pour le moment ; sinon, choisissez Nouveau flux de travail pour les voir.

La liste comprend :

• Briefing matinal — lit deux sites et enregistre les principaux articles de chacun dans un seul briefing.
• Surveiller une page — vérifie une page et ne vous prévient que si elle a changé.
• Veille thématique et Synthèse hebdomadaire de recherche — cherchent ou approfondissent un sujet et tiennent une synthèse à jour.
• Présentation des chiffres de la semaine et Section du rapport mensuel — mettent à jour une présentation (Présentations) ou un brouillon (Rédaction) que vous choisissez.
• Résumer les nouveaux articles et Dossier de réception — s’exécutent une fois pour chaque nouvel article d’un flux, ou chaque nouveau fichier d’un dossier.
• Comparer des notes à mes documents — compare un fichier de notes à des passages de vos collections de documents.
• Partir de zéro — un flux de travail vide que vous construisez étape par étape.

Repérez Résumer les nouveaux articles et choisissez Utiliser celui-ci. Conduit crée le flux de travail et ouvre sa page.

— agrandir Agrandir

Le nouveau flux de travail comporte déjà quatre étapes : il récupère l’article, demande au modèle de le résumer, enregistre le résumé et affiche une notification. Rien ne s’exécute encore ; un flux de travail qui surveille un flux ne commence à le surveiller qu’une fois Exécuter automatiquement activé, ce que vous ferez à l’étape 9. Vous allez maintenant le pointer vers les versions de uv.

Étape 2 — Pointer le flux de travail vers un flux de versions

Ce qui déclenche un flux de travail se règle dans sa section Démarre quand. Dans cette étape, vous allez remplacer le flux que celui-ci surveille, le blog de Rust, par les versions de uv.

Sur la page du flux de travail, choisissez Modifier. L’en-tête affiche le nom du flux de travail avec Modifier en JSON, Annuler et Enregistrer. Les étapes sont à gauche ; un panneau latéral à droite contient Départ (avec les choix de Démarre quand), puis Demandé à chaque exécution, Assistants et Réglages du workflow, où vous réglez le nom, la description, le fournisseur de modèles et le dossier.

Faites ces modifications :

1. Dans Réglages du workflow, remplacez le Nom par uv releases.
2. Sous Démarre quand, laissez un nouvel article apparaît dans un flux sélectionné et réglez Adresse du flux sur https://github.com/astral-sh/uv/releases.atom.
3. Réglez Vérifier toutes les sur 360 minutes. Un suivi de versions n’a pas besoin de regarder toutes les demi-heures ; quatre vérifications par jour suffisent largement.

Les autres choix sous Démarre quand sont Seulement quand je le lance, ou selon un horaire, pour les flux de travail que vous lancez à la main ou à heures fixes ; un nouveau fichier apparaît dans le dossier du workflow, qui demande d’abord de choisir un dossier dans Réglages du workflow ; et un connecteur signale du nouveau.

— agrandir Agrandir

Le flux de travail surveille maintenant le bon flux. Vous allez voir comment sa première étape utilise l’article qui a déclenché l’exécution.

Étape 3 — Récupérer les notes de version

Chaque exécution d’un flux de travail sur un flux concerne un article, et les informations de cet article sont à la disposition de toutes les étapes sous forme de valeurs. Dans cette étape, vous allez voir comment la première étape en utilise une pour récupérer les notes de version.

Faites défiler jusqu’à Étapes. Chaque étape est une carte titrée de son numéro et de son type, comme 1. Récupérer des pages, avec un court identifiant à côté, ici fetch. C’est grâce à cet identifiant que les étapes suivantes y font référence.

Le champ Page 1 de l’étape de récupération contient une pastille pour le lien de l’article. Ces valeurs s’insèrent avec le menu Insérer une valeur… à côté de chaque champ, qui liste ce qui est disponible à cet endroit du flux de travail :

• Du déclencheur — le titre, le lien, le résumé, la date et l’identifiant de l’article.
• Étapes précédentes — ce que les étapes au-dessus ont produit, par exemple fetch · texte de la première page.
• Demandé à chaque exécution — des valeurs que vous renseignez au lancement du flux de travail, si vous en ajoutez.

Laissez l’étape de récupération telle quelle. Pour uv, le lien de chaque article est la page GitHub de cette version : l’étape récupère donc les notes de version. Une étape de récupération lit jusqu’à dix pages, garde jusqu’à 50 000 caractères de chacune, et ne récupère que des adresses https publiques.

Remarquez le réglage En cas d’échec, réessayer sur la carte : par défaut, une récupération est retentée deux fois, ce qui absorbe un bref problème de réseau. Chaque étape a aussi Continuer même si cette étape échoue. Laissez-le désactivé ici : sans les notes de version, il n’y a rien à résumer.

Le flux de travail sait maintenant lire chaque nouvelle version. Vous allez ensuite dire au modèle ce qu’il doit en faire.

Étape 4 — Rédiger l’étape de résumé et choisir son modèle

Une étape Demander au modèle envoie une instruction et un texte à un modèle et garde sa réponse. Dans cette étape, vous allez rédiger une instruction adaptée aux notes de version et choisir un modèle peu coûteux pour cette seule étape.

Repérez l’étape 2, Demander au modèle, dont l’identifiant est summary. Remplacez son Instruction par ce qui suit :

Summarize these release notes for a developer who uses this tool every day.
List new features and fixes in at most five bullet points.
Then add a section titled "Breaking changes" that lists anything that could break
an existing project, such as removed options, changed defaults or new minimum versions.
If there are none, write exactly: No breaking changes.

Le champ Texte à traiter contient déjà le titre de l’article suivi du texte récupéré, afin que le modèle sache quelle version il lit. Laissez-le tel quel.

La dernière ligne de l’instruction compte. À l’étape 6, vous utiliserez cette phrase exacte pour décider de vous notifier ou non : on demande donc au modèle de l’écrire de la même façon à chaque fois.

Choisissez maintenant le modèle. Sous Modèle pour cette étape, la valeur par défaut est Utiliser le modèle du workflow, et le réglage Modèle du flux de travail, en haut de l’éditeur, est par défaut Suivre le modèle de la conversation, c’est-à-dire le dernier modèle que vous avez choisi dans une conversation. Pour un résumé de routine, choisissez plutôt un modèle rapide et peu coûteux. Ce tutoriel utilise GLM 5.3 Flash via OpenRouter.

— agrandir Agrandir

Le flux de travail produit maintenant un résumé dont la dernière section est prévisible. Vous allez ensuite vous assurer que chaque résumé est conservé.

Étape 5 — Enregistrer chaque résumé

Une étape Enregistrer un document stocke du texte sous forme de document que vous pourrez rouvrir plus tard. Dans cette étape, vous allez la régler pour garder un document par version.

Repérez l’étape 3, Enregistrer un document, et réglez :

• Titre — uv suivi de la pastille Titre de l’article, pour que chaque document porte le nom de sa version.
• Contenu — laissez la pastille du résumé et la ligne Source: avec le lien de l’article.
• Enregistrer comme — Document.
• À chaque exécution — Ajoute un nouveau document.

L’autre choix pour À chaque exécution, Remplace le même document, garde un seul document avec le dernier résultat, ce qui convient à la surveillance d’une page ou à un briefing quotidien. Pour un historique de versions, il vous faut un document par version.

L’enregistrement vient avant la vérification que vous allez ajouter, et c’est voulu : chaque version est conservée, même celles qui ne demandent pas votre attention aujourd’hui.

Vous allez maintenant ajouter l’étape qui décide de vous notifier ou non.

Étape 6 — Ne notifier que les changements incompatibles

Une étape Continuer seulement si… vérifie une valeur et met fin à l’exécution sans bruit si la vérification échoue. Dans cette étape, vous allez en ajouter une entre l’enregistrement et la notification, afin de n’être notifié que pour les versions qui comportent des changements incompatibles.

En bas de Étapes, ouvrez Ajouter une étape… et choisissez Continuer seulement si…. La nouvelle étape est ajoutée à la fin : utilisez donc son bouton ↑ pour la placer au-dessus de Afficher une notification. Réglez ensuite :

• Valeur à vérifier — insérez summary · texte depuis Étapes précédentes.
• Continuer seulement si — ne contient pas.
• Texte — No breaking changes.

La comparaison ignore les majuscules et les espaces superflus. Les autres tests sont a changé depuis la dernière exécution, n’est pas vide, est vide, contient et est égal à ; le premier est celui que le modèle de départ Surveiller une page utilise pour ne vous prévenir que lorsqu’une page change.

Enfin, mettez à jour l’étape 5, Afficher une notification. Réglez Titre sur Breaking changes in uv et Message sur la pastille Titre de l’article.

Si le modèle oublie un jour la phrase exacte, la vérification laisse passer la notification : au pire, vous recevez une notification dont vous n’aviez pas besoin, jamais un changement incompatible raté.

Choisissez Enregistrer. Si quelque chose ne tient pas, par exemple une étape qui lit une valeur qui n’existe pas encore, l’éditeur le liste sous Corrigez ceci avant d’enregistrer: et laisse Enregistrer désactivé tant que ce n’est pas corrigé. Une fois enregistrée, la page du flux de travail liste les cinq étapes en langage clair.

— agrandir Agrandir

Le flux de travail est terminé. Avant de le laisser s’exécuter seul, vous allez le tester.

Étape 7 — Tester le flux de travail avec Exécuter maintenant

Une exécution de test vous montre exactement ce que fera le flux de travail, avec des données réelles. Dans cette étape, vous allez l’exécuter une fois à la main.

Sur la page du flux de travail, choisissez Exécuter maintenant. Pour un flux de travail qui surveille un flux, une exécution à la main prend l’article le plus récent du flux comme test : vous n’avez pas à attendre la prochaine version. Le bouton devient Exécution en cours…, un bouton Arrêter apparaît, et l’exécution s’affiche sous Exécutions récentes comme Exécution de test : suivi du nom de la version.

Presque tout le temps d’exécution est celui de l’étape du modèle. Avec GLM 5.3 Flash, l’exécution de test présentée ici a pris moins d’une minute. Une fois terminée, son statut indique Terminé si la version comportait des changements incompatibles et que vous avez reçu une notification, ou Rien de nouveau si la vérification a mis fin à l’exécution après l’enregistrement du résumé. Dans les deux cas, Enregistré: renvoie au résumé enregistré.

— agrandir Agrandir

Attendez-vous à ce qu’un modèle juge les versions limites différemment d’une exécution à l’autre. uv 0.12.24 était surtout composée de corrections de bugs, dont certaines rendent uv plus strict, comme la vérification des empreintes fournies même lorsque la vérification des empreintes est désactivée. Lors de deux exécutions de test sur cette version, GLM 5.3 Flash a une fois classé ces corrections parmi les changements incompatibles et une fois écrit No breaking changes. Si vous voulez être prévenu de ce genre de changements, dites-le dans l’instruction, par exemple : Count bug fixes that make uv stricter as breaking changes.

Pour des étapes comme celle-ci, choisissez un modèle qui répond directement. Un modèle qui raisonne longuement avant de répondre peut mettre de nombreuses minutes sur une longue page, et une exécution s’arrête lorsqu’elle atteint sa limite de 30 minutes.

Vous allez maintenant ouvrir l’exécution et voir ce qu’a fait chaque étape.

Étape 8 — Lire une exécution et relancer une étape

Chaque exécution garde une trace de chaque étape : ce qui est entré, ce qui est sorti, quel modèle a été utilisé et combien de temps cela a pris. Dans cette étape, vous allez lire cette trace, modifier le résumé et ne relancer que les étapes qui en ont besoin.

Choisissez l’exécution de test sous Exécutions récentes. La section Ce qu’a fait cette exécution liste les étapes, chacune avec un statut : Terminé, Échec, Ignoré ou Réutilisé. Si la vérification a mis fin à l’exécution, on lit Rien de nouveau — arrêté à suivi de l’identifiant de l’étape, ici check.

Développez l’étape summary. Une ligne qui commence par le nom du modèle suivi de « utilisé » indique le modèle et le fournisseur employés, et en dessous figurent l’Entrée et la Sortie de l’étape. Sous Enregistré:, choisissez le nom du document pour ouvrir le résumé lui-même.

Supposons que le résumé soit plus long que vous ne le voulez. Choisissez Modifier, remplacez at most five bullet points par at most three bullet points, puis enregistrez. Rouvrez ensuite l’exécution de test, repérez l’étape summary et choisissez Réexécuter à partir de cette étape.

La nouvelle exécution marque l’étape de récupération comme Réutilisé : elle reprend les notes de version de l’exécution précédente au lieu de les récupérer à nouveau, et exécute le résumé, l’enregistrement, la vérification et la notification avec votre nouvelle instruction. Dans l’exécution présentée ci-dessous, la réexécution a pris 10 secondes, contre 16 pour l’exécution complète, parce que la page n’a pas été récupérée de nouveau. Sur un flux de travail plus long, cela économise à la fois du temps et des appels au modèle.

— agrandir Agrandir

Si une exécution échoue, la même vue montre quelle étape a échoué et pourquoi, en langage clair. Corrigez cette étape, puis relancez à partir d’elle.

Le flux de travail fait ce que vous voulez. Vous allez maintenant le laisser s’exécuter seul.

Étape 9 — Activer les exécutions automatiques

Un flux de travail qui s’exécute seul doit d’abord être approuvé. Dans cette étape, vous allez passer en revue ce que le suivi de versions a le droit de faire et l’activer.

Sur la page du flux de travail, choisissez la pastille Démarre sous la description (en vue Canevas, sélectionnez plutôt l’étape Départ). Le panneau Départ s’ouvre avec une section Planification ; cochez Exécuter automatiquement. (← Retour dans le panneau ramène au flux de travail.) Conduit affiche un panneau intitulé Le laisser s’exécuter seul ?, qui liste tout ce que le flux de travail aura le droit de faire sans demander. Pour le suivi de versions, la liste est la suivante :

• Lire les pages sur github.com — pour lire le flux.
• Lire les pages aux adresses que l’étape « fetch » obtient lors de son exécution — l’adresse de l’étape de récupération vient du flux, donc Conduit ne peut pas nommer le site à l’avance.
• Envoyer du texte à OpenRouter, en ligne — pour l’étape de résumé.
• Enregistrer des documents.

Les notifications et la vérification n’ont besoin d’aucune approbation. Choisissez Autoriser et activer. La section affiche alors Surveillance de github.com toutes les 360 min, et une ligne qui commence par Lorsqu’il s’exécute seul, il peut : garde la liste approuvée sous les yeux.

— agrandir Agrandir

Si vous modifiez plus tard le flux de travail de sorte qu’il ait besoin de quelque chose en plus, comme un nouveau site ou un autre fournisseur, la page affiche Il a besoin de votre accord pour plus avec un bouton Approuver. Tant que vous n’approuvez pas, une exécution automatique qui atteint cette étape s’arrête et demande. Vous recevez une notification, l’exécution affiche À vous, et l’Accueil la liste sous À vous. Vous pouvez choisir Autoriser une fois, Toujours autoriser ou Ne pas autoriser ; si personne ne répond en une journée, l’étape n’a pas lieu.

La première fois que vous activez les exécutions automatiques, Conduit propose aussi de Continuer à s’exécuter dans la zone de notification. Les exécutions automatiques n’ont lieu que pendant que Conduit est ouvert : acceptez si vous fermez souvent la fenêtre. Vous pourrez le modifier plus tard dans la même section, de même que Démarrer Conduit dans la zone de notification à l’ouverture de session.

— agrandir Agrandir

Le suivi de versions s’exécute maintenant seul. Dans la dernière étape, vous allez découvrir une façon plus rapide de démarrer le suivant.

Étape 10 — Décrire un flux de travail au lieu de le construire

Vous n’avez pas à construire chaque flux de travail étape par étape. Dans cette étape, vous allez demander à Conduit d’en rédiger un à partir d’une phrase.

Sur la page Flux de travail, choisissez Nouveau flux de travail. Dans Décrire un flux de travail, saisissez :

Chaque jour de la semaine à 9 h 00, lis la page d’accueil de Hacker News et celle de Lobsters, et enregistre une seule liste des articles sur Rust ou Python.

Choisissez Créer le brouillon. Le modèle de la conversation rédige un flux de travail, Conduit le vérifie comme il vérifie un flux de travail que vous enregistrez, et renvoie les éventuels problèmes au modèle pour qu’il les corrige. Le brouillon s’ouvre dans l’éditeur non enregistré : rien n’est enregistré ni planifié tant que vous n’avez pas choisi Enregistrer et activé le flux de travail vous-même.

Le modèle ne choisit jamais ce que vous seul pouvez choisir, comme un dossier, une présentation ou une collection de documents, et il n’active pas les horaires. Quand un brouillon a besoin de l’un de ces éléments, l’éditeur affiche À compléter avant d’enregistrer avec une courte liste. Pour la description ci-dessus, la liste indique Activer la planification : tous les jours de la semaine à 9 h 00., un rappel pour régler l’horaire sur la page du flux de travail après l’enregistrement.

— agrandir Agrandir

Il existe deux autres façons de partir de mots pour créer un flux de travail :

• Depuis l’Accueil. Saisissez ce que vous voulez dans la zone de saisie et choisissez la pastille Automatiser ; Conduit ouvre Flux de travail et rédige le brouillon.
• Depuis une conversation. Après avoir fait quelque chose à la main dans une conversation, ouvrez la palette de commandes avec Ctrl+K (⌘K sur macOS) et choisissez Enregistrer la conversation comme flux de travail…. Le brouillon repose sur ce que vous avez demandé et sur les outils utilisés ; le modèle ne voit pas les pages ou les documents eux-mêmes.

Dans les deux cas, relisez le brouillon, testez-le avec Exécuter maintenant, et ne cochez Exécuter automatiquement qu’ensuite.

Pour aller plus loin : canevas, branches et agents

Le surveillant de versions est une ligne droite, mais un flux de travail n’y est pas obligé. Quatre éléments prolongent ce que vous venez de faire.

• Le canevas. Choisissez Canevas dans la vue des étapes pour voir le départ, chaque étape, les boucles et les liens entre elles. Pendant une exécution, chaque étape indique si elle s’exécute, est terminée, a échoué, a été ignorée ou vous attend, et sélectionner une étape montre son entrée et sa sortie. Dans l’éditeur, vous pouvez ajouter des étapes depuis une palette, les faire glisser pour les réordonner, et tirer un lien d’une étape à une autre pour choisir quelle sortie va dans quel champ, au lieu de la saisir.
• Des branches et des étapes côte à côte. Une étape Si… sinon envoie l’exécution sur le chemin Oui ou Non ; le chemin non emprunté est enregistré comme Non emprunté. Une étape peut attendre plusieurs étapes précédentes : celles qui ne dépendent pas les unes des autres s’exécutent donc côte à côte, jusqu’à quatre à la fois, et une étape suivante peut les réunir. Remplacer l’étape Continuer seulement si… du surveillant de versions par une branche permettrait par exemple de notifier sur un chemin et seulement d’enregistrer sur l’autre.
• Les résultats. Tout ce qu’une exécution terminée a enregistré est conservé avec un aperçu. Ouvrez l’onglet Résultats d’un flux de travail, ou la liste Résultats de la barre latérale Flux de travail pour tous les flux, puis utilisez Ouvrir pour le lire.
• Les agents. Une étape Laisser le modèle utiliser des outils peut utiliser jusqu’à dix outils de connecteur et confier des tâches à des assistants que vous définissez, chacun avec ses propres consignes, son modèle et sa limite de tokens. Un outil de connecteur qui envoie, publie ou modifie quelque chose met l’exécution en pause et demande, et la Réception rassemble tout ce que vos flux de travail attendent. Avec Paramètres → Ordinateur activé, un agent peut aussi lancer des commandes et modifier des fichiers dans un dossier que vous désignez, et chaque commande demande d’abord, sauf si une règle que vous avez autorisée la couvre. La documentation des flux de travail liste les limites.

Tous les types d’étapes en un coup d’œil

Le suivi de versions utilise cinq sortes d’étapes. Les voici toutes, telles qu’elles apparaissent dans le menu Ajouter une étape… :

Un flux de travail peut contenir jusqu’à 50 étapes. Chaque champ de texte de chaque étape peut inclure des valeurs insérées, et toute la définition peut être modifiée à la main avec Modifier en JSON dans l’éditeur. Dans cette vue, les valeurs insérées s’écrivent {{steps.summary.text}} ou {{trigger.link}} ; pour écrire les accolades elles-mêmes, placez une barre oblique inverse devant : \{{.

À titre de référence, voici le suivi de versions que vous avez construit, tel que la vue JSON l’affiche :

{
  "steps": [
    {
      "id": "fetch",
      "type": "fetch_page",
      "urls": [
        "{{trigger.link}}"
      ]
    },
    {
      "id": "summary",
      "input": "{{trigger.title}}\n\n{{steps.fetch.text}}",
      "model": {
        "model": "z-ai/glm-5.3-flash",
        "provider": "openrouter"
      },
      "prompt": "Summarize these release notes for a developer who uses this tool every day.\n…",
      "type": "summarize"
    },
    {
      "content": "{{steps.summary.text}}\n\nSource: {{trigger.link}}",
      "id": "save",
      "mode": "create",
      "title": "uv {{trigger.title}}",
      "type": "save_artifact"
    },
    {
      "id": "check",
      "is": "not_contains",
      "text": "No breaking changes",
      "type": "condition",
      "value": "{{steps.summary.text}}"
    },
    {
      "body": "{{trigger.title}}",
      "id": "notify",
      "title": "Breaking changes in uv",
      "type": "notify"
    }
  ],
  "trigger": {
    "everyMinutes": 360,
    "kind": "feed",
    "url": "https://github.com/astral-sh/uv/releases.atom"
  }
}

Questions

Conclusion

Dans ce tutoriel, vous avez construit un flux de travail qui surveille les versions de uv : il récupère les notes de chaque nouvelle version, les résume avec un modèle peu coûteux, enregistre chaque résumé et ne vous notifie que des changements incompatibles. Vous l’avez testé sur une vraie version, lu ce qu’a fait chaque étape, relancé à partir de l’étape que vous aviez modifiée, et approuvé exactement ce qu’il peut faire seul.

Le même schéma — récupérer quelque chose, interroger le modèle à son sujet, garder le résultat et ne vous alerter que lorsque c’est utile — convient à de nombreuses routines. Essayez de pointer une copie vers les versions de chaque outil dont dépend votre projet, d’utiliser Surveiller une page sur une page de tarifs ou d’état, ou de laisser Dossier de réception résumer chaque fichier que vous déposez dans un dossier. Pour aller plus loin, consultez ces guides :

• La documentation des flux de travail, pour chaque réglage et chaque limite.
• Faire une recherche approfondie avec Conduit et Exa, pour découvrir les recherches que lance l’étape Faire des recherches sur un sujet d’un flux de travail.
• Les guides des fournisseurs (en anglais), pour choisir et configurer les modèles qu’utilisent vos flux de travail.

Télécharger Conduit

Les détails sur Conduit correspondent à la dernière version et peuvent être vérifiés dans la documentation et le code source. Une erreur ? Signalez-la-nous et nous la corrigerons.

À lire aussi

• Faire une recherche approfondie avec Conduit et Exa — Activez la recherche Exa, rédigez un brief et lisez un rapport cité dans Conduit, avec les cellules solaires comme exemple. Aucune clé Exa nécessaire.
• Comment présenter un serveur MCP à un client — Héberger un serveur MCP n’est pas une démo client. Comparaison entre un chat hébergé, Claude Desktop avec une extension et votre propre client desktop.