Il est 3h du matin. Dans un datacenter quelque part en Europe, un modèle de langage analyse son 400 000e contrat d’assurance. Personne ne surveille. Personne n’a besoin de surveiller. Ce qui aurait pris trois ans à une équipe de juristes vient de se faire en une nuit.

Ce n’est pas de la science-fiction. C’est ce que nous avons déployé chez un grand groupe d’assurance européen en 2024.

Le problème qu’on ne voyait pas

Les directions informatiques ont longtemps sous-estimé le vrai coût du traitement documentaire. Pas les coûts visibles — les salaires, les licences logicielles — mais les coûts invisibles : les contrats mal catégorisés, les clauses ambiguës jamais remontées, les litiges qui auraient pu être évités si quelqu’un avait eu le temps de tout lire.

Personne n’a le temps de tout lire.

Un contrat commercial moyen fait 47 pages. Un groupe de taille moyenne en gère des centaines de milliers. La réalité c’est que 80% de ces documents ne sont lus qu’en cas de problème — quand il est déjà trop tard.

Ce que les LLMs changent fondamentalement

Les modèles de langage de nouvelle génération ne font pas que “lire” des documents. Ils comprennent le contexte, détectent les incohérences, extraient des entités avec une précision chirurgicale, et surtout — ils le font de manière cohérente, sans fatigue, sans biais d’humeur.

Voilà ce qu’on a mis en place concrètement :

# Pipeline d'extraction structurée via LLM
from anthropic import Anthropic
import json

client = Anthropic()

def extract_contract_data(contract_text: str) -> dict:
    """
    Extrait les données structurées d'un contrat via Claude.
    Retourne un dict JSON avec toutes les clauses clés.
    """
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=2048,
        system="""Tu es un expert juridique spécialisé en droit des contrats suisse.
        Extrais les informations suivantes en JSON strict, sans commentaires :
        - parties (array): noms et rôles des parties
        - date_signature: format ISO 8601
        - duree_mois: integer
        - montant_total: float en CHF
        - clauses_risque: array de strings, clauses identifiées comme risquées
        - juridiction: string
        - resiliation_preavis_jours: integer
        Réponds UNIQUEMENT avec le JSON, rien d'autre.""",
        messages=[{
            "role": "user",
            "content": f"Analyse ce contrat :\n\n{contract_text[:15000]}"
        }]
    )
    return json.loads(response.content[0].text)

# Traitement en batch avec gestion d'erreurs
def process_contract_batch(contracts: list[str]) -> list[dict]:
    results = []
    for i, contract in enumerate(contracts):
        try:
            data = extract_contract_data(contract)
            results.append({"status": "ok", "data": data})
        except json.JSONDecodeError as e:
            results.append({"status": "error", "reason": str(e)})
        
        if i % 100 == 0:
            print(f"Traité : {i}/{len(contracts)} contrats")
    
    return results

Le résultat ? 97.3% de précision sur l’extraction des clauses clés, validé par comparaison avec l’analyse manuelle d’un échantillon de 2 000 contrats par l’équipe juridique.

Mais ce n’est pas que de la performance

Ce qui m’a frappé lors de ce projet, c’est que la vraie valeur n’était pas dans la vitesse. Elle était dans ce que la vitesse permettait de voir.

Quand vous pouvez analyser 400 000 contrats en une nuit, vous commencez à poser des questions que vous ne pouviez pas poser avant. Quel pourcentage de nos contrats ont des clauses de résiliation à 30 jours vs 90 jours ? Dans quels secteurs nos clauses de responsabilité sont-elles les plus exposées ? Quels fournisseurs ont des préavis anormalement courts ?

Ce sont des questions stratégiques. Et elles n’ont de réponse que si vous avez les données.

Les trois erreurs que tout le monde fait au démarrage

1. Penser que le prompt suffit. Un LLM sans pipeline de validation produit des résultats impressionnants… jusqu’au premier edge case. Toujours prévoir une couche de validation structurelle (JSON schema, règles métier) en sortie du modèle.

2. Ignorer les coûts de contexte. Envoyer 47 pages à un LLM à chaque requête, c’est cher. La bonne approche : chunking intelligent, extraction préalable des sections pertinentes par heuristique simple, puis appel LLM ciblé.

3. Déployer sans monitoring. Un pipeline LLM en production sans observabilité, c’est voler à l’aveugle. Loggez les tokens, les latences, les taux d’erreur, les déviations de distribution dans les outputs.

Ce qui arrive ensuite

Nous sommes en 2025. Dans les trois prochaines années, chaque grand groupe aura un pipeline de ce type en production. La question n’est plus “si” mais “comment bien le faire”.

Les entreprises qui prennent de l’avance maintenant ne gagnent pas juste de l’efficacité opérationnelle. Elles construisent un corpus de données structurées sur leur propre activité — une ressource qui va devenir un avantage concurrentiel durable.

Le groupe pour lequel nous avons déployé ce système peut aujourd’hui répondre en quelques secondes à des questions qui prenaient auparavant des semaines d’analyse. Leur équipe juridique ne fait plus de saisie. Elle fait de la stratégie.

C’est ça, la vraie promesse des LLMs en entreprise.

Vous réfléchissez à intégrer des LLMs dans vos processus métier ? Parlons-en.