ChatGPT · Automatiser le travail récurrent avec la stack OpenAI
Le brief concurrentiel que vous rédigez chaque lundi matin (parcourir cinq blogs de concurrents, résumer les changements de prix, coller le tout dans un e-mail) peut tourner tout seul pendant que vous dormez. L'astuce consiste à cesser de traiter ChatGPT comme un endroit où l'on se rend et à traiter l'API OpenAI comme un composant que l'on planifie. Cette leçon transforme un chat répété en pipelinepipelineL'ensemble des opportunités commerciales actives réparties selon les étapes du processus de vente, avec leur valeur potentielle cumulée et leur probabilité de conclusion.Voir la définition complète → qui tourne sans intervention. Elle couvre aussi les garde-fousgarde-fousRègles et contrôles qui maintiennent un système d'IA dans des limites sûres, légales et conformes à la marque, en bloquant les sorties et actions hors cadre.Voir la définition complète → qui évitent que cela devienne coûteux ou embarrassant.
Deux façons d'automatiser : dans le produit ou via l'APIAPIApplication Programming Interface : une interface standardisée qui permet aux applications de communiquer et d'échanger des données sans connaître leur fonctionnement interne respectif.Voir la définition complète →
Avant d'écrire du code, sachez qu'OpenAI propose une option no-code. Dans ChatGPT, les tâches planifiées permettent de demander à l'assistant d'exécuter un prompt de façon récurrente et de vous notifier. C'est utile pour des rappels personnels et des digests légers. Voir Scheduled tasks in ChatGPT.
Mais les tâches planifiées vivent dans votre compte ChatGPT. Elles peuvent difficilement faire un commit dans un repo, écrire dans votre data warehousedata warehouseUn référentiel central qui consolide les données de nombreux systèmes sources dans un stockage structuré et optimisé pour les requêtes, conçu pour l'analytique, le reporting et la business intelligence.Voir la définition complète → ou envoyer des e-mails via le fournisseur transactionnel de votre entreprise. Il vous faut parfois une vraie intégration, du contrôle de version ou un compte de service qui n'est pas lié à votre login personnel. À ce stade, vous passez à l'API associée à un planificateur externe.
La règle de décision :
- Une personne, sortie légère, simple notification : tâches planifiées ChatGPT.
- Sortie partagée, vrais systèmes, exécutions auditables : API + cron ou CI.
La suite de cette leçon traite de la seconde voie.
Le pipeline, en quatre étapes
Notre exemple : chaque lundi à 6 h, récupérer le contenu récent des concurrents, produire un brief structuré, le mettre en forme en e-mail et l'envoyer.
Un job planifié n'est que quatre étapes assemblées :
- Collecter les entrées (flux RSS, quelques URL, le brief de la semaine précédente).
- Générer le brief via l'API.
- Valider la sortie par rapport à un schémamaUtiliser un logiciel pour automatiser les tâches et campagnes marketing répétitives, afin de personnaliser à grande échelle sur des canaux comme l'email, le web et le social.Voir la définition complète →.
- La livrer (e-mail, Slack, fichier commité).
Le modèle ne prend en charge que l'étape 2. Gardez la collecte, la validation et la livraison en code simple plutôt qu'en appels au modèle. C'est ce qui rend le pipeline peu coûteux et prévisible.
Pourquoi les sorties structurées sont non négociables ici
Dans un chat, vous lisez de la prose et passez à autre chose. Dans un pipeline, l'étape suivante est du code qui doit *parser* le résultat. Si le modèle renvoie des formes légèrement différentes d'une semaine à l'autre, votre moteur de rendu d'e-mail casse.
Utilisez Structured Outputs pour forcer le modèle à renvoyer un JSON conforme à un schéma que vous définissez. Demander poliment (« merci de renvoyer du JSON ») n'est pas fiable. Avec Structured Outputs, l'API contraint la génération à votre schéma. Lisez Structured Outputs.
Construire le générateur de brief
Voici l'appel central avec la Responses API, l'interface principale d'OpenAI pour les nouveaux développements. Le bloc text.format verrouille la réponse sur un schéma.
import json
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
SCHEMA = {
"type": "object",
"properties": {
"summary": {"type": "string"},
"items": {
"type": "array",
"items": {
"type": "object",
"properties": {
"competitor": {"type": "string"},
"headline": {"type": "string"},
"why_it_matters": {"type": "string"},
"source_url": {"type": "string"},
},
"required": ["competitor", "headline", "why_it_matters", "source_url"],
"additionalProperties": False,
},
},
},
"required": ["summary", "items"],
"additionalProperties": False,
}
def build_brief(gathered_text: str) -> dict:
resp = client.responses.create(
model="gpt-5-mini",
input=[
{"role": "system", "content": "You are a competitive analyst. "
"Only use facts present in the provided sources. If a claim is "
"not supported, omit it. Never invent pricing or dates."},
{"role": "user", "content": gathered_text},
],
text={"format": {"type": "json_schema", "name": "brief",
"schema": SCHEMA, "strict": True}},
max_output_tokens=2000,
)
return json.loads(resp.output_text)Avec responses.create, le JSON arrive sous forme de texte dans resp.output_text, et c'est à vous de le charger. Si vous préférez des objets typés, client.responses.parse() accepte un modèle Pydantic et vous fournit resp.output_parsed.
Trois choix délibérés :
- Un petit modèle bon marché (
gpt-5-miniici, ougpt-5-nanosi vos evals le permettent) gère très bien la synthèse. Réservez les modèles frontier complets aux tâches qui demandent un raisonnement lourd. C'est votre principal levier de coût. "strict": Truegarantit que le JSON est valide, si bien que l'étape de livraison peut faire le rendu sans parsing défensif.- Le prompt systèmeprompt systèmeLes instructions cachées qui définissent le comportement d'un assistant IA avant toute question : son rôle, son ton, ses limites et ses règles.Voir la définition complète → interdit l'invention. Les jobs récurrents tournent sans surveillance : un prix concurrent halluciné peut atterrir dans la boîte d'un dirigeant avant que quiconque ne le remarque.
Collecter les entrées sans fenêtre de contexte géante
Ne collez pas cinq blogs complets dans le prompt en payant des tokenstokensUn token est l'unité de base de texte que traitent les modèles de langage : le plus souvent un fragment de mot, un mot entier ou un signe de ponctuation, plutôt qu'un simple caractère.Voir la définition complète → inutiles. Récupérez chaque flux, ne gardez que les entrées plus récentes que votre dernière exécution et réduisez chaque article à sa partie introductive. Votre gathered_text devient un digest compact et daté. Moins de contexte, c'est un coût plus faible, des exécutions plus rapides et moins d'occasions pour le modèle de s'égarer.
C'est aussi là que vous stockez l'état. Écrivez last_run.json après chaque exécution réussie pour ne traiter, la semaine suivante, que les éléments *nouveaux*. Un pipeline qui résume à nouveau les mêmes articles chaque semaine est à la fois coûteux et bruyant.
Livraison : rendre, puis envoyer
Tenez le modèle complètement à l'écart de la livraison. Prenez le JSON validé, mettez-le en forme avec un template, puis envoyez-le via l'outil que votre organisation utilise déjà.
def render_email(brief: dict) -> str:
lines = [f"<p>{brief['summary']}</p>", "<ul>"]
for item in brief["items"]:
lines.append(
f"<li><b>{item['competitor']}:</b> {item['headline']}. "
f"{item['why_it_matters']} "
f"<a href='{item['source_url']}'>source</a></li>"
)
lines.append("</ul>")
return "".join(lines)Envoyez via le SDK de votre fournisseur d'e-mails transactionnels ou en SMTP. **Le modèle a produit des *faits structurés*, et du code déterministe a produit l'*artefact***. Si la mise en page de l'e-mail doit changer, vous modifiez un template, pas un prompt.
Le planifier
Rendez-le maintenant récurrent. Vous avez deux options propres.
Option A : cron sur un petit serveur
Sur n'importe quelle machine Linux allumée en permanence, lancez crontab -e :
# Lundi 06:00, écrire les logs, ne jamais laisser un crash passer inaperçu
0 6 * * 1 cd /opt/briefs && /opt/briefs/.venv/bin/python run.py >> /var/log/brief.log 2>&1 || curl -s "$ALERT_WEBHOOK" -d "brief job failed"C'est simple, mais le serveur, le fichier de secrets et la disponibilité sont à votre charge.
Option B : GitHub Actions (recommandé pour la plupart des équipes)
L'intégration continue (CI) désigne un environnement hébergé qui exécute votre script sur un déclencheur. Les runners CI sont gratuits pour des jobs planifiés légers, les secrets sont gérés pour vous et chaque exécution est journalisée.
name: weekly-brief
on:
schedule:
- cron: "0 6 * * 1" # Les lundis à 06:00 UTC
workflow_dispatch: {} # permet de le lancer manuellement pour tester
jobs:
brief:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: pip install -r requirements.txt
- run: python run.py
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
EMAIL_API_KEY: ${{ secrets.EMAIL_API_KEY }}workflow_dispatch est la ligne sous-estimée. Elle vous donne un bouton « Run workflow » qui permet de tester tout le pipeline à la demande sans attendre lundi. Les secrets vivent dans les paramètres chiffrés du repo, jamais dans le code.
Schedule Python Scripts with GitHub Actions
Les garde-fous qui le rendent sûr et peu coûteux
Un job sans surveillance qui appelle une API payante et envoie des e-mails à votre équipe a besoin de limites. Fixez-les avant la mise en production, pas après une facture surprise.
Garde-fous de coût
- Définissez une limite d'usage dans le dashboard de l'API pour qu'une boucle incontrôlée ne puisse pas vider votre compte. Voir production best practices.
- Plafonnez la sortie avec
max_output_tokens. Un brief n'a pas besoin de 4 000 tokens. Avec les modèles GPT-5, les tokens de raisonnement comptent dans ce plafond. Gardez de la marge, ou définissezreasoning={"effort": "minimal"}pour une synthèse simple. - Utilisez un projet et une clé API dédiés à ce job. Les clés par projet montrent exactement ce que coûte ce pipeline, et vous pouvez révoquer la clé indépendamment.
- Choisissez le modèle le moins cher qui passe votre eval. Retestez de temps en temps, car les modèles moins chers continuent de progresser.
Garde-fous d'exactitude
- Limitez le modèle aux sources récupérées et exigez une
source_urlpar élément (le schéma l'impose déjà). Un élément dont l'URL ne figure pas dans vos sources collectées est un signal d'alerte : votre code peut l'écarter. - Ajoutez un contrôle de cohérence entre la validation et la livraison. Si
itemsest vide, envoyez « aucun changement notable cette semaine » plutôt qu'une coquille vide. Si la liste est anormalement longue, signalez-la pour revue.
Garde-fous opérationnels
- Échouez bruyamment. Un job cron silencieux qui a cessé de tourner il y a trois semaines est pire que pas de job du tout. Appelez un webhook en cas d'échec (voir l'exemple cron).
- Relancez les erreurs transitoires avec backoff. Les coupures réseau et les rate limits arrivent : enveloppez l'appel API dans un retry de quelques tentatives.
- Journalisez l'usage de tokens et le coût de chaque exécution, même en cas de succès, pour repérer les dérives.
Vérification des acquis
1. Selon la leçon, quel changement d'état d'esprit fondamental faut-il opérer pour automatiser une tâche récurrente avec la stack OpenAI ?
2. Une équipe a besoin d'un brief automatisé qui fait un commit dans un repo partagé, utilise un compte de service non lié à un login personnel et produit des exécutions auditables. Quelle approche la leçon recommande-t-elle ?
3. Dans le pipeline en quatre étapes (collecter, générer, valider, livrer), pourquoi la leçon insiste-t-elle pour que seule l'étape 2 soit un appel au modèle ?
4. Sélectionnez TOUTES les affirmations exactes sur Structured Outputs tel que décrit dans la leçon.
Sélectionnez toutes les réponses correctes.
5. Sélectionnez TOUS les scénarios dans lesquels les tâches planifiées ChatGPT (l'option no-code) sont un choix approprié selon la leçon.
Sélectionnez toutes les réponses correctes.
Passer à l'échelle : quand un seul prompt ne suffit pas
La conception à appel unique ci-dessus est le bon point de départ, et elle couvre une part étonnante du travail récurrent. N'ajoutez de la structure que lorsque la tâche l'exige.
Quand ajouter des outils
Parfois, le job doit décider *quelles* sources récupérer, ou appeler des systèmes en direct comme une API de prix ou un moteur de recherche interne. Dans ce cas, donnez au modèle le function calling pour qu'il puisse demander ces actions, et laissez votre code les exécuter. Le modèle propose et votre code dispose : le modèle ne touche jamais à rien que vous n'ayez explicitement autorisé.
Quand utiliser le SDK Agents
Certains jobs comportent plusieurs étapes : collecter, rédiger, critiquer le brouillon, réviser, puis mettre en forme. Pour ceux-là, l'OpenAI Agents SDK orchestre les étapes, les outils et les handoffs, ce qui vous évite de coder la boucle de contrôle à la main. Utilisez-le quand votre pipeline a une vraie logique de branchement. L'utiliser pour résumer un seul flux relève de la sur-ingénierie, et chaque appel supplémentaire au modèle ajoute de la latence et du coût.
Un mot sur l'agent ChatGPT et Codex
L'agent ChatGPT peut naviguer et agir dans une session pour accomplir des tâches, et Codex peut écrire et exécuter du code pour vous. Les deux sont excellents pour *construire et prototyper* ce pipeline de manière interactive. La version de production d'un job récurrent doit être du code déterministe sous contrôle de version, exécuté par un planificateur. Une session d'agent interactive demande d'être surveillée en permanence. Construisez avec l'agent, livrez avec l'API.
Assembler le tout
Votre run.py se résume maintenant aux quatre étapes en séquence :
def main():
state = load_state("last_run.json")
gathered = gather_sources(feeds, since=state["last_run"])
if not gathered.strip():
notify("No new competitor content this week.")
return
brief = build_brief(gathered)
if not brief["items"]:
notify("No notable changes this week.")
return
send_email(render_email(brief))
save_state("last_run.json", now())
if __name__ == "__main__":
main()Lisible, testable et ennuyeux, au meilleur sens du terme. Le modèle tient en une ligne au milieu. Tout ce qui l'entoure est du code simple et débogable, et c'est ce qu'il vous faut pour quelque chose qui tourne sans que vous le surveilliez.
Points clés
- Ne confiez au modèle que la génération. La collecte, la validation et la livraison relèvent du code déterministe, et c'est cette séparation qui rend les jobs planifiés peu coûteux et fiables.
- Imposez Structured Outputs avec
"strict": True. Avecresponses.create, chargezoutput_texten JSON. Utilisezresponses.parsesi vous voulezoutput_parsed. - Pour les équipes, planifiez avec GitHub Actions : secrets gérés, exécutions journalisées et bouton
workflow_dispatchpour tester à la demande. N'utilisez cron que si vous maîtrisez la machine. - Mettez les garde-fous en place avant la mise en production : une limite d'usage stricte, une clé API par projet et le modèle le moins cher qui passe votre eval (commencez par
gpt-5-miniougpt-5-nano). Ajoutez un plafond de tokens de sortie qui laisse de la place aux tokens de raisonnement, et un webhook d'échec pour qu'un job mort ne passe jamais inaperçu. - Construisez en interactif, livrez en déterministe. Prototypez avec l'agent ChatGPT ou Codex, mais exécutez le job récurrent sous forme de code versionné. Ne recourez au SDK Agents que si la tâche comporte un vrai branchement en plusieurs étapes.
Questions fréquentes
Quand utiliser les tâches planifiées de ChatGPT plutôt que l'API OpenAI ?
Utilisez les tâches planifiées de ChatGPT quand une seule personne a besoin d'un digest récurrent léger ou d'un rappel livré sur son propre compte. Passez à l'API OpenAI avec un planificateur externe dès que le résultat est partagé, qu'il doit écrire dans de vrais systèmes comme un entrepôt de données, un repo ou un fournisseur d'e-mails transactionnels, ou que les exécutions doivent être auditables sous un compte de service plutôt que sous un login personnel.
Comment structurer un job planifié qui appelle l'API OpenAI ?
Découpez-le en quatre étapes : collecter les entrées, générer avec l'API, valider le résultat par rapport à un schéma, puis le livrer. Le modèle ne prend en charge que l'étape de génération ; la collecte, la validation et la livraison restent du code déterministe classique. C'est cette séparation qui garde le job peu coûteux, testable et prévisible semaine après semaine.
Pourquoi ai-je besoin des Structured Outputs au lieu de simplement demander du JSON au modèle ?
Parce que « merci de renvoyer du JSON » n'est pas fiable, et que dans un pipeline l'étape suivante est du code qui doit parser le résultat. Si la structure change d'une exécution à l'autre, votre moteur de rendu casse. Les Structured Outputs contraignent la génération à un schéma que vous définissez ; avec "strict": true, le JSON est garanti valide, et l'étape de livraison n'a besoin d'aucun parsing défensif.
Comment planifier un script Python qui utilise l'API OpenAI sans faire tourner mon propre serveur ?
GitHub Actions s'en charge : un workflow avec un déclencheur cron `on: schedule` exécute votre script sur un runner hébergé, stocke vos clés d'API dans les secrets chiffrés du repo et journalise chaque exécution. Ajoutez `workflow_dispatch: {}` pour obtenir un bouton manuel « Run workflow » et tester le pipeline complet à la demande. Un simple cron sur une machine Linux fonctionne aussi, mais le serveur, le fichier de secrets et la disponibilité sont alors à votre charge.
Comment maîtriser le coût d'un job OpenAI qui tourne sans surveillance ?
Fixez une limite d'usage dans le dashboard de l'API pour qu'une boucle incontrôlée ne puisse pas vider le compte, et donnez au job son propre projet et sa propre clé d'API pour voir exactement ce qu'il coûte et pouvoir le révoquer isolément. Choisissez le modèle le moins cher qui passe votre eval, par exemple gpt-5-mini ou gpt-5-nano pour du résumé. Plafonnez `max_output_tokens`, en gardant en tête qu'avec les modèles GPT-5 les tokens de raisonnement comptent dans ce plafond, et réduisez les entrées au lieu de coller des articles entiers.
Faut-il utiliser l'Agents SDK d'OpenAI pour un job de résumé récurrent ?
Non, pas pour une seule étape de résumé. Un unique appel d'API avec un schéma couvre une part étonnante du travail récurrent, et chaque appel supplémentaire au modèle ajoute de la latence et du coût. L'Agents SDK se justifie quand le pipeline comporte de vraies ramifications : collecter, rédiger, critiquer, réviser, mettre en forme. Utilisez l'agent ChatGPT ou Codex pour prototyper, puis déployez le job récurrent sous forme de code déterministe versionné.
À faire, tiré de cette leçon
Ces actions sont compilées dans le plan d'action du rôle.
- Rédigez les Tasks planifiées comme des prompts complets et autonomes, en précisant le comportement en semaine creuse
- Fixez des plafonds de facturation stricts avec des clés API distinctes par environnement
- Confiez au modèle la seule génération ; collectez, validez et livrez dans le code