Comment utiliser l'IA pour automatiser ses tâches quotidiennes

Credit : Logo officiel

Comment utiliser l'IA pour automatiser ses tâches quotidiennes

Dylan D. — Agent Support Technique Serveur IA 2269 mots 12 min de lecture

Trois mois de support automatisé

L'an dernier, j'ai automatisé une bonne partie de mon flux de travail au support technique avec Claude API et quelques scripts bash. Résultat : la classification des tickets entrants se fait toute seule, les réponses standard sont pré-rédigées, et je n'écris plus à la main les rapports d'incidents post-mortem. Sur les tickets que je traite chaque jour, je récupère environ 90 minutes par cycle de 8 heures — assez pour creuser les vrais cas tordus à la place de répéter les mêmes 20 réponses. Cet article détaille les workflows concrets que j'ai mis en place, avec les prompts qui marchent, les pièges à éviter, et les commandes pour brancher tout ça sur du Linux.

Choisir le bon modèle pour le bon usage

En 2026, les trois familles dominantes :

Mon arbitrage simple :

Tâche Modèle de choix Pourquoi
Code Bash/Python/PHP Claude Sonnet Suit mieux les contraintes
Email pro à reformuler GPT-4o Tons plus naturels
Analyse d'un PDF de 100 pages Gemini 2.5 Long contexte natif
Recherche web sourcée Perplexity Cite ses sources, pas de hallucination
Génération d'images Midjourney v7 Qualité visuelle
Code local sans cloud Ollama + Qwen 2.5 Souveraineté

N'utilise jamais un seul modèle aveuglément. Compare la sortie de deux modèles sur tes 5 tâches récurrentes, choisis le meilleur pour chacune.

Mesurer la qualité avant de migrer

J'ai monté un petit harness d'éval sur 30 cas réels (tickets passés, contenu critique). Pour chaque modèle, je note la sortie sur 5 critères : exactitude technique, ton, brièveté, hallucinations, suivi des contraintes. Sur ces 30 cas, Claude Sonnet 4.7 me sort 28/30 "prêt à envoyer", GPT-4o 24/30, Gemini 2.5 22/30. Mais inverse-les sur de la rédaction marketing pure et le classement change. Teste sur ton propre corpus avant de t'engager, jamais sur des benchmarks publics, ils sont déjà saturés par l'entraînement.

Workflow 1 : classer ses emails entrants

J'utilise un script Python avec l'API Claude qui se branche sur IMAP via imap-tools. Le prompt classe en 5 catégories :

#!/usr/bin/env python3
import os
from imap_tools import MailBox, AND
from anthropic import Anthropic

client = Anthropic(api_key=os.environ['ANTHROPIC_API_KEY'])
PROMPT = """Classe cet email en une seule catégorie parmi :
- URGENT (nécessite action sous 4h)
- CLIENT (demande client standard)
- INTERNE (collègue, équipe)
- NEWSLETTER (à archiver)
- SPAM

Réponds uniquement par le mot-clé.

Email :
{body}
"""

with MailBox('imap.ionos.fr').login('dylan@monsite.fr', os.environ['IMAP_PASS']) as mb:
    for msg in mb.fetch(AND(seen=False), limit=20):
        resp = client.messages.create(
            model="claude-sonnet-4-7",
            max_tokens=20,
            messages=[{"role": "user", "content": PROMPT.format(body=msg.text[:3000])}]
        )
        label = resp.content[0].text.strip()
        mb.flag(msg.uid, label, True)  # ajoute le tag IMAP
        print(f"{msg.subject[:40]:<40} → {label}")

Lancé via cron toutes les 15 minutes :

*/15 * * * * /usr/bin/python3 /opt/scripts/classify-mail.py >> /var/log/ai-mail.log 2>&1

Coût observé : environ 0,50 € par mois pour 200 mails/jour avec Claude Haiku, 2 € avec Sonnet. Sur 6 mois j'ai zéro faux positif sur la catégorie SPAM, ce qui était mon plus gros risque.

Workflow 2 : rédaction de réponses standard

Pour les questions récurrentes ("comment changer mon mot de passe SSH ?"), je garde un fichier de prompts "templates" et j'envoie chaque ticket à Claude pour générer le brouillon de réponse :

#!/bin/bash
# generate-reply.sh
TICKET_TEXT="$(cat $1)"
PROMPT="Tu es Dylan, agent support IONOS.
Ton : tutoiement, concret, commandes Linux exactes.
Réponse : 200 mots max, étapes numérotées si plusieurs actions.

Ticket client :
$TICKET_TEXT

Génère ta réponse :"

curl -s https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d "{
    \"model\": \"claude-sonnet-4-7\",
    \"max_tokens\": 800,
    \"messages\": [{\"role\": \"user\", \"content\": $(jq -Rs . <<< "$PROMPT")}]
  }" | jq -r '.content[0].text'

Usage : ./generate-reply.sh ticket-123.txt > brouillon.txt. Je relis, corrige, j'envoie. Gain : 5 minutes par ticket.

Affiner avec quelques exemples

J'ai amélioré la qualité du brouillon en ajoutant 3 exemples ("few-shot") en début de prompt. Concrètement, je colle 3 anciens couples ticket→réponse-validée que j'ai relus et signés. Le ton du modèle se cale dessus immédiatement, et le taux de réécriture passe de 40 % à 12 %. C'est l'astuce qui fait la différence entre "IA qui sort un truc générique" et "IA qui imite ma voix".

Workflow 3 : résumés de logs serveur

Quand un client signale "mon site était down hier soir", j'ai un script qui aspire les logs des dernières 24h et envoie l'extrait pertinent à Claude :

#!/bin/bash
# log-postmortem.sh
DOMAIN=$1
from=$(date -d "24 hours ago" '+%d/%b/%Y:%H:%M')

LOGS=$(grep "$DOMAIN" /var/log/nginx/access.log | awk -v from="$from" '$4 >= "["from' | tail -2000)
ERRORS=$(grep "$DOMAIN" /var/log/nginx/error.log | tail -200)

cat <<EOF | curl -s https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d @- | jq -r '.content[0].text'
{
  "model": "claude-sonnet-4-7",
  "max_tokens": 1500,
  "messages": [{"role": "user", "content": "Analyse ces logs Nginx, identifie : (1) pic de trafic, (2) erreurs récurrentes, (3) IPs suspectes, (4) action recommandée. Logs access:\n$LOGS\n\nLogs erreur:\n$ERRORS"}]
}
EOF

La sortie est un mini post-mortem prêt à coller dans le ticket.

Exemple de sortie réelle

# Analyse incident 02/05/2026 sur monclient.fr

Pic trafic : 21h14-21h28, 4200 req/min (x12 baseline).
Origine : 188 IPs distinctes, AS GoogleBot et Googlebot-Image.
Légitime : oui, nouveau sitemap soumis 19h.

Erreurs : 217 x 502 sur /produit/*, début 21h22.
Cause probable : PHP-FPM saturé (pm.max_children=8).

Action : monter pm.max_children à 16, relancer php-fpm.
Long terme : activer cache Redis pour /produit/*.

C'est le genre de synthèse que je faisais en 30 minutes à la main. Là, 4 secondes.

Workflow 4 : génération de contenu pour le blog

Je ne laisse pas l'IA écrire mes articles (sinon Google détecte et déclasse), mais je l'utilise pour :

Prompt pour les plans :

Tu es éditeur tech. Écris-moi un plan détaillé pour un article de 2000 mots
sur le sujet : "{SUJET}".

Contraintes :
- 6 à 8 sections H2
- Au moins 3 sections doivent inclure des commandes shell
- Une section "Erreurs courantes" avec 4-5 messages d'erreur exacts
- Public cible : sysadmin junior
- Ton : tutoiement, concret

Rends uniquement le plan, pas le contenu.

Workflow 5 : IA dans le terminal avec llm

L'outil llm de Simon Willison est mon couteau suisse CLI :

# Installer
pip install llm llm-anthropic
llm keys set anthropic

# Demander une commande
llm -m claude-sonnet-4-7 "Donne-moi la commande awk pour extraire les IP uniques d'un access.log Nginx"

# Pipe pour analyser
dmesg | tail -100 | llm "Y a-t-il des erreurs hardware critiques ?"

# Continuer une conversation
llm -c "Et comment je liste les disques NVMe ?"

Je le branche aussi sur du fzf pour avoir l'historique de mes prompts navigable :

llm logs list | fzf --preview 'echo {} | jq .response'

Workflow 6 : exécution multi-étapes avec n8n

Quand un workflow dépasse 3 étapes, le bash devient ingérable. Je passe sur n8n auto-hébergé qui me sert de chef d'orchestre. Exemple concret : un nouveau ticket arrive sur Zendesk → n8n détecte le webhook → appelle Claude pour classer + générer brouillon → écrit dans Notion + ping Slack si URGENT.

Docker-compose minimal :

services:
  n8n:
    image: n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=n8n.monsite.fr
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.monsite.fr/
      - GENERIC_TIMEZONE=Europe/Paris
    volumes:
      - /opt/n8n:/home/node/.n8n

Puis Nginx en reverse proxy avec Let's Encrypt par-dessus. Sur un VPS S (1 €/mois), n8n tourne avec 200 Mo de RAM et encaisse plusieurs milliers d'exécutions par jour.

Sécurité et confidentialité

Ne jamais envoyer à un LLM externe :

Mes garde-fous :

# Mask les secrets avant envoi
sed -E 's/(password|api_key|token)=[^ ]+/\1=REDACTED/g' input.txt | llm "..."

# Vérifier qu'aucune adresse email client ne fuite
grep -E '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+' avant_envoi.txt && echo "STOP, emails détectés"

Pour les données très sensibles, j'utilise un modèle local Ollama avec Llama 3.3 ou Qwen 2.5 :

curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5:14b
ollama run qwen2.5:14b "Explique cette config Nginx"

Tout reste sur la machine, zéro fuite réseau. Sur un Ryzen 7 avec 32 Go de RAM, Qwen 2.5 14b tourne à environ 25 tokens/sec — assez pour un usage interactif, beaucoup trop lent pour du batch.

Audit RGPD du flux IA

J'ai fait l'exercice de cartographier toutes les requêtes API IA partant de mon poste. Pour chaque endpoint (Anthropic, OpenAI, Mistral), je documente : type de données envoyées, durée de rétention chez le fournisseur, opt-out training. Anthropic et OpenAI proposent une option "zero data retention" pour les comptes Pro/Team — il faut explicitement la cocher. Mistral, hébergé en France, offre le compromis souveraineté + qualité, à coût comparable.

Mesurer le ROI réel

L'enthousiasme pour l'IA peut faire perdre de vue le coût réel. Sur 3 mois, j'ai chronométré :

Tâche Temps avant Temps après Coût mensuel
Classer 200 mails/jour 25 min 2 min 1,80 €
Brouillon 30 tickets/jour 90 min 25 min 8,40 €
Post-mortem 5/semaine 150 min 20 min 1,20 €
Plan d'article hebdo 40 min 8 min 0,30 €

Gain mensuel : ~30 heures pour 12 € d'API. Le SMIC horaire chargé étant à 17 €, le ROI est obscène. Mais il n'apparaît qu'après avoir investi 2-3 jours à monter les scripts proprement et stabiliser les prompts.

Suivi du coût en continu

Je me suis monté un dashboard Grafana qui ingère les factures Anthropic et OpenAI via leur API d'usage. Une simple table SQLite stocke chaque appel, avec son nombre de tokens entrée/sortie, son coût calculé et le workflow appelant. En un coup d'œil je vois quand un workflow dérape (par exemple un loop infini qui appelle l'API 10 000 fois en une nuit). Le seuil d'alerte Grafana est posé à 5 € par jour : au-delà, je reçois un mail et je peux couper la clé. Ce garde-fou m'a sauvé deux fois en 2025, dont une où un test mal écrit aurait coûté 80 €.

Le verrou final : prompt versionné dans Git

Dernier conseil que peu de gens appliquent : versionne tes prompts comme du code. Je garde un dossier ~/prompts/ avec un fichier .md par workflow, commité sur un dépôt Git privé. Chaque modification fait l'objet d'un commit avec message explicatif. Quand un workflow régresse, je fais un git diff sur le prompt et je vois immédiatement ce qui a changé. C'est trivial, mais ça transforme tes prompts en actif maintenu plutôt qu'en bricolage qui dérive.

Erreurs courantes et leur fix

401 Unauthorized sur l'API Anthropic
Cause : variable ANTHROPIC_API_KEY non chargée. Vérifie : echo $ANTHROPIC_API_KEY | head -c 10. Si vide, source ton .env ou re-exporte.

Réponse tronquée à 100 tokens
Cause : max_tokens trop bas dans la requête. Pour Claude, monte à 4096 ou 8192. Attention : c'est facturé sortie.

Hallucinations sur des commandes Linux
Cause : tu n'as pas donné assez de contexte. Précise la version de Debian, le shell, la stack. Toujours vérifier une commande avant de la lancer en prod.

Rate limit exceeded sur OpenAI
Cause : trop de requêtes/minute. Implémente un backoff exponentiel :

import time
for attempt in range(5):
    try:
        resp = client.create(...)
        break
    except RateLimitError:
        time.sleep(2 ** attempt)

Coût qui explose en fin de mois
Mets une alerte budget. Sur Anthropic Console : Settings → Limits → Monthly spend limit. Sur OpenAI : Settings → Billing → Usage limits. Je plafonne à 50 €/mois pour mes scripts perso.

Sortie qui dérive de format JSON attendu
Cause : le modèle ajoute du texte avant ou après le JSON. Solutions : utiliser response_format={'type': 'json_object'} côté OpenAI, ou pour Claude forcer le préfixe assistant à { (prefilling) — le modèle continue forcément en JSON valide.

Pour aller plus loin

Le bon dosage : assistant, pas pilote

L'IA augmente ma productivité de 30 à 40 % sur les tâches répétitives, mais elle ne remplace ni le jugement technique ni la responsabilité. Je relis systématiquement chaque réponse avant envoi, je teste chaque commande avant prod, je signe chaque post-mortem. Commence petit : automatise une seule tâche, mesure le gain, étends progressivement. C'est comme cron : tu le branches sur ce que tu maîtrises déjà à la main. Et garde toujours la main sur le "kill switch" — un script IA mal calibré peut envoyer 500 mauvais mails avant que tu t'en aperçoives.

# Articles similaires

Sur les memes sujets et plus loin