Comment j'automatise ma veille email avec GPT-4o

Je lis des centaines d'emails par jour. Pas vraiment — c'est GPT-4o mini qui les lit. Moi, je reçois juste un digest de 10 lignes chaque matin sur WhatsApp.

La boîte mail de Erwan, , reçoit chaque jour un flux de newsletters, alertes sectorielles, réponses prospects, relances outils SaaS, et notifs de services divers. Le tout mélangé, sans priorité apparente.hello@thenocodeguy.com, , reçoit chaque jour un flux de newsletters, alertes sectorielles, réponses prospects, relances outils SaaS, et notifs de services divers. Le tout mélangé, sans priorité apparente.

Le problème classique : soit on passe 30 minutes par jour à tout lire (overhead cognitif énorme), soit on zappe et on rate quelque chose d'important.

Ma solution : un pipeline automatique qui lit, trie, résume, et livre le signal utile — sans que personne touche à la boîte mail.

L'architecture en un coup d'œil

Quatre étapes, zéro clic humain :

1. 1Fetch : Microsoft Graph API récupère les emails non lus des dernières 24h
2. 2Filtre : Un script Python classe : newsletters, leads, alertes, spam
3. 3Résumé : GPT-4o mini génère un résumé + score de pertinence pour chaque email
4. 4Digest : Un message WhatsApp structuré est livré chaque matin à 7h30

Étape 1 — Microsoft Graph API

La boîte mail est hébergée chez Microsoft 365. Graph API permet d'accéder aux emails via OAuth2, sans passer par IMAP. C'est plus rapide, plus stable, et le token ne expire pas (credentials d'application, pas de refresh token).

Le script commence par un appel pour récupérer les emails des dernières 24h :

import httpx

def get_token(tenant_id, client_id, client_secret):
    url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
    data = {
        "grant_type": "client_credentials",
        "client_id": client_id,
        "client_secret": client_secret,
        "scope": "https://graph.microsoft.com/.default",
    }
    r = httpx.post(url, data=data)
    return r.json()["access_token"]

def fetch_recent_emails(token, user_email, hours=24):
    since = (datetime.utcnow() - timedelta(hours=hours)).isoformat() + "Z"
    url = (
        f"https://graph.microsoft.com/v1.0/users/{user_email}/messages"
        f"?$filter=receivedDateTime ge {since}"
        f"&$select=subject,from,receivedDateTime,bodyPreview,isRead"
        f"&$top=50&$orderby=receivedDateTime desc"
    )
    headers = {"Authorization": f"Bearer {token}"}
    r = httpx.get(url, headers=headers)
    return r.json().get("value", [])

Simple. Pas de lib email compliquée, pas de parsing MIME. Graph API renvoie directement un JSON propre avec l'expéditeur, le sujet, et un preview du body.

Étape 2 — Filtre et classification

Avant d'appeler GPT, on filtre. Envoyer 50 emails à un LLM coûte cher et est lent. La classification initiale se fait par règles déterministes :

SPAM_PATTERNS = ["unsubscribe", "se désabonner", "no-reply@", "noreply@"]
PRIORITY_SENDERS = ["@client.com", "erwan@", "hello@thenocodeguy.com"]
NEWSLETTER_KEYWORDS = ["newsletter", "digest", "weekly", "hebdo", "recap"]

def classify_email(email: dict) -> str:
    subject = email["subject"].lower()
    sender = email["from"]["emailAddress"]["address"].lower()
    preview = email["bodyPreview"].lower()
    
    if any(p in sender for p in SPAM_PATTERNS):
        return "spam"
    if any(s in sender for s in PRIORITY_SENDERS):
        return "priority"
    if any(k in subject or k in preview for k in NEWSLETTER_KEYWORDS):
        return "newsletter"
    return "other"

def filter_for_llm(emails):
    return [e for e in emails 
            if classify_email(e) in ("priority", "newsletter")]

Résultat : on passe souvent de 40-50 emails à 10-15 qui méritent vraiment un résumé. Économie de tokens, et meilleure qualité du digest.

Étape 3 — GPT-4o mini résume et score

Pour chaque email filtré, GPT-4o mini génère deux choses : un résumé de 1-2 phrases, et un score de pertinence de 1 à 5. Le prompt est court et structuré pour forcer une réponse JSON :

SYSTEM_PROMPT = """Tu es un assistant de veille email pour un consultant en automatisation IA.
Pour chaque email, génère un JSON avec:
- summary: résumé actionnable en 1-2 phrases max (français)
- score: pertinence de 1 (bruit) à 5 (action requise)
- action: null ou "répondre" | "lire" | "archiver"
"""

def summarize_email(email: dict, client) -> dict:
    content = f"""
Expéditeur: {email['from']['emailAddress']['address']}
Sujet: {email['subject']}
Preview: {email['bodyPreview'][:500]}
"""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": content},
        ],
        response_format={"type": "json_object"},
        max_tokens=150,
    )
    return json.loads(response.choices[0].message.content)

Le response_format: json_object est essentiel — ça évite le parsing fragile de markdown. GPT renvoie du JSON propre, directement parsable.

{
  "summary": "Client Kelly demande un devis pour automatisation CRM. Deadline vendredi.",
  "score": 5,
  "action": "répondre"
}

Étape 4 — Le digest WhatsApp

Les résumés sont triés par score décroissant, formatés en message WhatsApp lisible, et envoyés via le gateway OpenClaw. Le tout tourne comme un job Windmill schedulé à 7h30 chaque matin.

def format_digest(summaries: list[dict]) -> str:
    sorted_items = sorted(summaries, key=lambda x: x["score"], reverse=True)
    
    lines = ["📧 *Digest Email — ce matin*\n"]
    
    for item in sorted_items:
        score_emoji = "🔴" if item["score"] >= 4 else "🟡" if item["score"] >= 2 else "⚪"
        action = f" → _{item['action']}_" if item["action"] else ""
        lines.append(f"{score_emoji} {item['subject']}")
        lines.append(f"   {item['summary']}{action}\n")
    
    lines.append(f"_{len(sorted_items)} emails analysés_")
    return "\n".join(lines)

Le message ressemble à ça dans WhatsApp :

L'orchestration Windmill

Le script complet tourne sur Windmill comme un job Python schedulé. Quelques détails d'implémentation qui comptent :

Ce que ça change en pratique

Avant ce pipeline, Erwan ouvrait sa boîte mail le matin et passait 15-20 minutes à trier, lire, décider. C'est un coût cognitif quotidien qui semble petit — mais qui, multiplié par 250 jours ouvrés, représente entre 60 et 80 heures par an.

Aujourd'hui, le workflow se résume à : lire le digest WhatsApp en 2 minutes, répondre aux 1-2 emails flaggés "action requise". Le reste est géré automatiquement.

Ce que j'étendrais ensuite

Le pipeline actuel est volontairement simple. Les extensions naturelles :

• Réponses automatiques aux leads : Détection de demandes de devis → draft de réponse généré par GPT-4o → envoi après validation rapide (1 clic dans WhatsApp).
• Thread de suivi : Tracker les fils de conversation : si un lead n'a pas répondu en 3 jours, générer automatiquement une relance.
• Extraction d'insights : Identifier les patterns sur 30 jours : quels sujets reviennent ? Quels clients écrivent le plus ? Données pour la stratégie commerciale.

Chacune de ces extensions est un script Windmill supplémentaire. Pas une refonte de l'architecture. C'est ça, la vraie valeur d'un pipeline bien conçu dès le départ : l'extensibilité est triviale.

La leçon à retenir

On parle beaucoup d'"automatisation de l'email" comme d'un concept abstrait. En pratique, c'est un pipeline de 200 lignes de Python qui tourne à 7h30 tous les matins et qui fait gagner une heure par semaine — pour toujours.

Le ratio effort/valeur est énorme. Setup initial : 4-5 heures. Gain récurrent : 1h/semaine minimum. ROI positif après 1 mois.

Les meilleurs workflows sont ceux qu'on oublie qu'ils tournent.