Trier des e-mails clients avec un modèle open-weight sur un Mac : Granite, Qwen et Gemma

brew install ollama        # ou brew upgrade ollama
ollama serve               # dans un terminal à part
ollama pull granite4.2:8b
ollama pull qwen3.5:9b
ollama pull gemma4:12b

python3 -m venv .venv && source .venv/bin/activate
pip install requests

[
  {
    "id": "e12",
    "texte": "Objet : avoir\n\nBonjour, vous m'aviez promis un avoir de 75 € suite au retard de la commande CMD-20301, puis on m'a parlé de 50 €. Au final je n'ai rien vu sur ma dernière facture. Merci de régulariser.\nCamille Petit\n07 50 40 30 20",
    "attendu": {
      "categorie": "facturation",
      "urgence": "normale",
      "nom": "Camille Petit",
      "commande": "CMD-20301",
      "telephone": "07 50 40 30 20",
      "montant": 75,
      "action": "appliquer l'avoir promis"
    }
  }
]

"""Trie un e-mail client avec un modèle local servi par Ollama.

Le modèle renvoie une fiche JSON : catégorie, urgence, coordonnées, montant,
action à mener. Deux façons d'obtenir le JSON :
  consigne (par défaut) -> le schéma est décrit dans la consigne, la réponse est
                           contrôlée ensuite ; marche avec tous les moteurs d'Ollama
  imposé                -> Ollama contraint la génération au schéma ; indisponible
                           avec le moteur MLX (« structured output is unavailable »)

Usage : python trier.py granite4.2:8b "texte de l'e-mail"
"""

import json
import re
import sys
import time

import requests

OLLAMA = "http://localhost:11434/api/chat"

CATEGORIES = ["livraison", "facturation", "support technique", "avant-vente", "résiliation", "autre"]
URGENCES = ["basse", "normale", "haute"]

SCHEMA = {
    "type": "object",
    "required": ["categorie", "urgence", "nom", "commande", "telephone", "montant", "action", "a_confirmer"],
    "properties": {
        "categorie": {"type": "string", "enum": CATEGORIES},
        "urgence": {"type": "string", "enum": URGENCES},
        "nom": {"type": ["string", "null"]},
        "commande": {"type": ["string", "null"]},
        "telephone": {"type": ["string", "null"]},
        "montant": {"type": ["number", "null"]},
        "action": {"type": "string"},
        "a_confirmer": {"type": "array", "items": {"type": "string"}},
    },
}

INSTRUCTIONS = """Tu tries les e-mails reçus par le service client d'un fournisseur de bureau.
Remplis la fiche à partir de l'e-mail, sans rien inventer.
- categorie : livraison, facturation, support technique, avant-vente, résiliation ou autre.
- urgence : haute si le client est bloqué, lésé financièrement, très mécontent ou si un délai
  imminent risque d'être manqué ; basse pour une question simple ou un remerciement ; sinon normale.
- nom : nom et prénom de la personne qui écrit, null si l'e-mail n'est pas signé par une personne.
- commande : le numéro de commande, de contrat ou de client cité, tel qu'il est écrit, sinon null.
  Un numéro de facture n'est pas un numéro de commande.
- telephone : tel qu'il est écrit, sinon null.
- montant : le montant en euros dont parle l'e-mail, sinon null.
- action : ce que le service client doit faire, en quelques mots.
- a_confirmer : les informations contradictoires ou douteuses ; liste vide s'il n'y en a pas.
Réponds uniquement par un objet JSON avec les clés categorie, urgence, nom, commande,
telephone, montant, action et a_confirmer."""


class FicheInvalide(ValueError):
    pass


def lire_json(texte: str) -> dict:
    """Extrait l'objet JSON de la réponse et vérifie qu'il respecte le schéma."""
    debut, fin = texte.find("{"), texte.rfind("}")
    try:
        fiche = json.loads(texte[debut : fin + 1])
    except ValueError as e:
        raise FicheInvalide(f"JSON illisible : {texte[:80]!r}") from e
    manquants = set(SCHEMA["required"]) - fiche.keys()
    if manquants:
        raise FicheInvalide(f"clés manquantes : {sorted(manquants)}")
    if fiche["categorie"] not in CATEGORIES or fiche["urgence"] not in URGENCES:
        raise FicheInvalide(f"valeur hors liste : {fiche['categorie']!r}, {fiche['urgence']!r}")
    if isinstance(fiche["montant"], str):  # « 389,90 € » -> 389.9
        nombre = re.sub(r"[^\d,.]", "", fiche["montant"]).replace(",", ".")
        fiche["montant"] = float(nombre) if nombre else None
    return fiche


def trier(model: str, email: str, think: bool = False, impose: bool = False) -> tuple[dict, dict]:
    """Renvoie la fiche et les mesures (durées en secondes, débit en jetons/s)."""
    start = time.perf_counter()
    corps = {
        "model": model,
        "messages": [
            {"role": "system", "content": INSTRUCTIONS},
            {"role": "user", "content": email},
        ],
        "think": think,
        "stream": False,
        "keep_alive": "10m",
        # num_predict borne la réponse : sans lui, un modèle qui raisonne peut tourner en boucle.
        "options": {"temperature": 0, "seed": 42, "num_ctx": 8192, "num_predict": 3000},
    }
    if impose:
        corps["format"] = SCHEMA
    r = requests.post(OLLAMA, json=corps, timeout=600)
    if not r.ok:
        raise RuntimeError(f"{r.status_code} {r.text}")
    data = r.json()
    stats = {
        "total": time.perf_counter() - start,
        "chargement": data.get("load_duration", 0) / 1e9,
        "jetons_sortie": data.get("eval_count", 0),
        "debit": data.get("eval_count", 0) / max(data.get("eval_duration", 1) / 1e9, 1e-9),
    }
    return lire_json(data["message"]["content"]), stats


if __name__ == "__main__":
    fiche, stats = trier(sys.argv[1], sys.argv[2])
    print(json.dumps(fiche, ensure_ascii=False, indent=2))
    print(f"{stats['total']:.1f} s, {stats['debit']:.0f} jetons/s")

python trier.py qwen3.5:9b "Bonjour, le lien pour télécharger ma facture ne marche pas. Commande CMD-20455."

"""Compare plusieurs modèles locaux sur les 12 e-mails de emails.json.

Pour chaque modèle : champs justes (6 par e-mail), catégories et urgences
justes, doute signalé sur l'e-mail contradictoire (e12), temps de chargement,
temps moyen par e-mail, débit et mémoire occupée. Les fiches sont gardées
dans resultats/.

Usage : python comparer.py granite4.2:8b qwen3.5:9b gemma4:12b
Suffixes : « +think » active le raisonnement, « +schema » fait imposer le JSON par
Ollama (moteur llama.cpp seulement). Exemple : granite4.2:8b+schema
"""

import json
import os
import re
import sys
import unicodedata

import requests

from trier import FicheInvalide, trier

CHAMPS = ["categorie", "urgence", "nom", "commande", "telephone", "montant"]


def norme(valeur):
    if valeur is None:
        return None
    if isinstance(valeur, (int, float)):
        return round(float(valeur), 2)
    texte = unicodedata.normalize("NFKD", str(valeur)).encode("ascii", "ignore").decode().lower()
    if re.fullmatch(r"[\d\s.+-]{10,}", texte):  # téléphone : on ne garde que les chiffres
        return re.sub(r"\D", "", texte)[-9:]
    return re.sub(r"\s+", " ", texte).strip(" .")


def juste(champ: str, obtenu, attendu) -> bool:
    if champ == "nom" and attendu and obtenu:
        return set(norme(attendu).split()) <= set(norme(obtenu).split())
    return norme(obtenu) == norme(attendu)


def memoire(model: str) -> float:
    """Mémoire occupée par le modèle chargé, en Go."""
    for m in requests.get("http://localhost:11434/api/ps", timeout=10).json()["models"]:
        if m["name"] == model:
            return m["size"] / 1e9
    return 0.0


def decharger() -> None:
    """Libère la mémoire occupée par les modèles déjà chargés."""
    for m in requests.get("http://localhost:11434/api/ps", timeout=10).json()["models"]:
        requests.post("http://localhost:11434/api/generate", json={"model": m["name"], "keep_alive": 0}, timeout=60)


if __name__ == "__main__":
    emails = json.load(open("emails.json"))
    os.makedirs("resultats", exist_ok=True)
    print(f"{'modèle':<24}{'champs':>8}{'catég.':>8}{'urgence':>9}{'doute e12':>10}"
          f"{'charg.':>8}{'s/mail':>8}{'jet./s':>8}{'Go':>6}  erreurs")
    for nom in sys.argv[1:]:
        model, *options = nom.split("+")
        decharger()  # un seul modèle en mémoire à la fois
        fiches, erreurs, durees, debits, chargement = {}, [], [], [], 0.0
        for i, email in enumerate(emails):
            try:
                fiche, stats = trier(model, email["texte"], "think" in options, "schema" in options)
            except FicheInvalide as e:  # fiche inexploitable : tous ses champs comptent faux
                fiche, stats = {"invalide": str(e)}, None
            if stats is None:
                erreurs += [f"{email['id']}.{champ}=invalide" for champ in CHAMPS]
                fiches[email["id"]] = fiche
                continue
            fiches[email["id"]] = fiche
            if i == 0:
                chargement = stats["chargement"]
            else:  # le premier appel inclut le chargement du modèle
                durees.append(stats["total"])
            debits.append(stats["debit"])
            for champ in CHAMPS:
                if not juste(champ, fiche.get(champ), email["attendu"][champ]):
                    erreurs.append(f"{email['id']}.{champ}={fiche.get(champ)!r}")
        with open(f"resultats/{nom.replace(':', '_')}.json", "w") as f:
            json.dump(fiches, f, ensure_ascii=False, indent=2)
        total = len(emails) * len(CHAMPS)
        n_cat = len(emails) - sum(".categorie=" in e for e in erreurs)
        n_urg = len(emails) - sum(".urgence=" in e for e in erreurs)
        doute = "oui" if fiches["e12"].get("a_confirmer") else "non"
        print(f"{nom:<24}{total - len(erreurs):>3}/{total:<4}{n_cat:>4}/12{n_urg:>5}/12{doute:>10}"
              f"{chargement:>7.1f}s{sum(durees) / len(durees):>7.1f}s{sum(debits) / len(debits):>8.0f}"
              f"{memoire(model):>6.1f}  {', '.join(erreurs) or '-'}")

python comparer.py granite4.2:8b+schema granite4.2:8b qwen3.5:9b gemma4:12b

{
  "categorie": "facturation",
  "urgence": "normale",
  "nom": "Camille Petit",
  "commande": "CMD-20301",
  "telephone": "07 50 40 30 20",
  "montant": 75.0,
  "action": "Vérifier l'état de l'avoir promis (75 €) et le montant évoqué ultérieurement (50 €), puis régulariser la situation sur la facture.",
  "a_confirmer": [
    "Montant de l'avoir : le client mentionne initialement 75 €, puis 50 €.",
    "Application de l'avoir : le client n'a rien vu sur sa dernière facture."
  ]
}

{
  "a_confirmer": [],
  "action": "Régulariser l'avoir de 75 € pour la commande CMD-20301 et vérifier la mention sur la dernière facture.",
  "categorie": "facturation",
  "commande": "CMD-20301",
  "montant": 75,
  "nom": "Camille Petit",
  "telephone": "07 50 40 30 20",
  "urgence": "normale"
}

ollama stop granite4.2:8b; ollama stop qwen3.5:9b; ollama stop gemma4:12b
# et pour supprimer les modèles du disque (environ 20 Go) :
ollama rm granite4.2:8b qwen3.5:9b gemma4:12b