Industrie / PME France — Playbook AI Engineer 2026

TL;DR Marché FR industrie : 2ème puissance industrielle UE (derrière Allemagne), ~250K entreprises industrielles (INSEE), dont ~6300 ETI et ~270 grandes entreprises (Thales, Dassault, Schneider, Saint-Gobain, Michelin, Safran, Airbus). Plan France 2030 : 54 Md€ pour réindustrialiser + IA. TJM réaliste freelance AI : 800-1300€/j (1500€+ pour défense/aéronautique). Top 3 clients-types : grands groupes industriels (Schneider Electric, Saint-Gobain, Thales, Dassault, Michelin), ETI industrielles (BPI accompagne 5500+), PME manufacturières (besoin no/low-code). Top 3 use cases : maintenance prédictive (vision + signaux), documentation technique RAG + assistant opérateur, qualité par vision. Spécificité : marché "lent à signer mais fidèle" — un client industriel garde 3-5 ans.

🎯 Pourquoi cette verticale en 2026

1. France 2030 + plan IA + relocalisation = pluie de subventions (BPI, ADEME, France 2030, France Relance). Les industriels ont des budgets fléchés "IA & transformation digitale" qu'ils doivent dépenser.

2. Pénurie de compétences industrielles. Les opérateurs partent à la retraite avec la connaissance. L'IA (RAG, assistants opérateurs) capture et restitue ce savoir-faire.

3. Coût énergie & matériaux explose depuis 2022 → maintenance prédictive et optimisation production deviennent critiques.

4. Schneider Electric, Saint-Gobain, Michelin, Dassault Systèmes ont des programmes IA matures et cherchent des freelances pour sujets ponctuels (ils ne peuvent pas tout faire en interne).

5. PME et ETI sont sous-équipées. Pas de DSI, pas d'AI Engineer interne. Tu peux faire la fonction "AI Engineer fractionnel" (1-2 jours/semaine sur 6-12 mois) — modèle TJM bas mais reccurent.

Honnêteté brutale :

Cycle de vente très long (6-12 mois pour grand groupe industriel, 2-4 mois pour ETI/PME).
Décideurs très conservateurs (production = critique, ne pas casser).
PME = budgets serrés (50-150K€/an total). Tu dois proposer des packages low-code et accessibles.
Beaucoup de "tourisme IA" : audits payés mais aucune production. Verrouille les conditions.
Air gap / OT / SCADA : la plupart des usines n'ont pas internet sur le shop floor → contraintes infra fortes.
Tu DOIS aller sur site. C'est la verticale la plus "physique" — déplacements obligatoires.

🗺️ Carte du marché français

Top 10 grands groupes industriels (cibles tier 1)

Acteur	Secteur	CA	Budget IA estimé
TotalEnergies	Énergie	~188 Md€ 2024 (vs 198 Md€ 2023)	200-400M€/an
EDF	Énergie	140 Md€	200-300M€/an
Engie	Énergie	80 Md€	100-200M€/an
Stellantis (FR portion)	Auto	190 Md€	200-400M€/an
Renault	Auto	56 Md€	100-200M€/an
Airbus	Aéronautique	65 Md€	200-300M€/an
Safran	Aéronautique	24 Md€	80-150M€/an
Thales	Défense / aéro	19 Md€	80-150M€/an
Dassault Aviation / Dassault Systèmes	Aéro / soft 3D	6.2 Md€ (Aviation 2024, +29% vs 2023) + ~6 Md€ (Systèmes)	100-200M€/an
Schneider Electric	Industrie / énergie	38 Md€	100-200M€/an

Tier 2 — ETI industrielles accessibles freelance

Saint-Gobain, Michelin, Pernod Ricard (process), Danone, L'Oréal Industriel (cosméto)
Plastic Omnium, Faurecia / Forvia, Valeo (équipementiers auto)
Legrand, Nexans, Sonepar (électrique)
Bouygues Construction, Vinci, Eiffage (BTP industriel)
Naval Group, MBDA, KNDS (ex KMW+Nexter Defense Systems, fusion 2024)
Arkema, Solvay (FR), Air Liquide (chimie)
Veolia, Suez (utilities / déchets)

PME / ETI manufacturières

Plus de 6300 ETI (Mouvement ETI, METI — chiffres 2023-2024)
Plasturgie, mécanique de précision, agroalimentaire, métallurgie
Tisseurs / textile (Roanne, Vallée de la Maurienne)
Outils France 2030 / BPI : tu peux entrer via ces accompagnements

Acteurs publics & soutien

BPI France (Banque Publique d'Investissement) — finance et accompagne
France 2030 — investissement État dans industrie
CEA (Commissariat à l'énergie atomique et aux énergies alternatives) — recherche industrielle
CETIM (Centre Technique des Industries Mécaniques)
DGE (Direction Générale des Entreprises)

Associations & événements pros

France Industrie (asso patronale industrie)
METI (Mouvement des ETI) — meti-france.fr
UIMM (Union Industries Métiers Métallurgie) — uimm.fr
FEBEA, ANIA, FIPA (agroalimentaire, plasturgie, etc.)
Salons : Global Industrie (mars/avril, Lyon) — LE salon industrie FR, VivaTech, Salon Maintenance Expo, Industrie du Futur, All4Tech

Médias spécialisés

L'Usine Nouvelle (référence industrie)
L'Usine Digitale (transformation numérique industrielle)
Industrie & Technologies
Mesures.com (instrumentation)
Maintenance & Entreprise
France Industrie newsletter

💼 Top 5 use cases AI

Use case 1 — Maintenance prédictive (vibration, vision, signaux)

Problème métier : une ligne de production qui s'arrête = 5-50K€/h. La maintenance préventive (calendrier) sur-maintient. La maintenance corrective (panne) coûte cher. La maintenance prédictive (data + ML) optimise.

Solution AI :

Capteurs IoT (vibration, température, courant moteur, qualité air)
Ingestion temps réel (MQTT, OPC-UA)
Modèles ML (autoencoder, isolation forest) pour anomaly detection
Vision (caméras inspection) : détection usure, fuites
Alerting + maintenance ticket dans GMAO (Carl Source, IBM Maximo, Sage)

Stack technique : Python + PyTorch / sklearn, Kafka / RabbitMQ, TimescaleDB, ClickHouse, edge devices (Jetson, Raspberry Pi industriel), intégration SCADA.

Mesure ROI : -30% temps d'arrêt non planifié, -20% coût maintenance global.

Exemple chiffré : Usine agroalimentaire, 8 lignes, arrêt non planifié coûte 300K€/an par ligne = 2.4M€. Réduction 30% = 720K€/an. Solution facturée : 200-300K€ build + 100K€/an run + part variable.

Use case 2 — RAG documentation technique + assistant maintenance

Problème métier : une usine a 10K-100K pages de documentation (modes opératoires, plans, fiches matériel, retours d'expérience). Un technicien passe 30-50% de son temps à chercher.

Solution AI :

Ingestion docs (PDF, Word, AutoCAD, photos), OCR + structuration
RAG via Qdrant + Mistral
Interface : tablette industrielle (Panasonic Toughpad), recherche vocale ou tape
Citations vers pages exactes
Sauvegarde Q&A → enrichissement base

Stack technique : Mistral Large, Qdrant, OCR Mistral, Next.js (back-office) + PWA mobile pour tablette, Postgres.

Mesure ROI : -40% temps de recherche documentaire, -25% temps d'intervention maintenance, capitalisation savoir-faire (départs retraite).

Exemple chiffré : Maintenance 50 techniciens, 30% temps = 15 ETP perdus à chercher. À 60K€/an chargé × 15 = 900K€/an. Réduction 40% = 360K€/an. Solution facturée : 120-180K€ build + 50K€/an.

Use case 3 — Assistant opérateur production (voice + mobile)

Problème métier : un opérateur sur ligne (debout, gants, bruit) ne peut pas taper. Il a besoin d'aide rapide (procédure, qualité, escalade). Les nouveaux opérateurs sont sous-formés.

Solution AI :

Tablette industrielle ou casque audio (Honeywell Vocollect)
Reconnaissance vocale (Whisper ou Deepgram FR)
Assistant LLM contextualisé par poste de travail
Lecture des consignes de production (titre court + détails à la demande)
Génération automatique d'incident (qualité, sécurité)

Stack technique : Whisper ou Deepgram, Claude Sonnet, mobile PWA ou Android natif, Mistral Vision pour photos défauts, OPC-UA pour data machine.

Mesure ROI : temps de formation nouvel opérateur ÷2, réduction défauts qualité 10-20%.

Exemple chiffré : Usine 200 opérateurs, formation moyenne 4 mois × 35K€ = 12K€/recrue × 30 recrues/an = 360K€/an. Réduction 30% = 108K€/an. + qualité = ~500K€/an valeur totale. Solution facturée : 150-200K€ build + 50K€/an.

Use case 4 — Contrôle qualité par vision

Problème métier : sur une ligne (mécanique, pharma, agroalimentaire), 1-5% de défauts non détectés visuellement. Coût retours / scrap.

Solution AI :

Caméras industrielles (Cognex, Basler, IDS) sur ligne
Modèle vision : classification défauts (YOLOv8, custom CNN)
LLM vision (Claude Sonnet, Mistral Vision) pour cas complexes
Annotation + boucle apprentissage continu
Intégration MES (Manufacturing Execution System)

Stack technique : PyTorch / Ultralytics YOLO, OpenCV, NVIDIA Jetson edge, MLflow pour versioning, Label Studio.

Mesure ROI : -90% défauts non détectés, -25% taux scrap, NPS client industriel +.

Exemple chiffré : Usine pharmaceutique, 1M unités/an, défaut non détecté 0.8% = 8000 unités × 10€ unité = 80K€ + risque rappel = 200K€/an. Réduction 80% = 160K€/an. Solution facturée : 180-250K€ build + 60K€/an.

Use case 5 — Recherche brevets + veille concurrentielle technique

Problème métier : un service R&D doit suivre brevets (Espacenet, USPTO, JPO) + publications scientifiques + sites concurrents. C'est 1-2 ETP perdus.

Solution AI :

Crawlers (Espacenet OPS API, USPTO, ArXiv, sites concurrents)
Classification thématique LLM
Résumé exécutif + alertes ciblées par projet R&D
Détection signaux faibles (mêmes inventeurs, mots-clés émergents)

Stack technique : Python (httpx, Scrapy), Qdrant, Mistral Large, FastAPI, alerting Slack/Teams.

Mesure ROI : -1 ETP veille R&D, accélération projets internes par signaux faibles.

Exemple chiffré : ETI 800 personnes, R&D 50 ingénieurs, veille = 2 ETP. Économie 1 ETP × 75K€ = 75K€/an. + valeur stratégique. Solution facturée : 60-90K€ build + 25K€/an.

🛠️ Stack technique typique Industrie FR

┌─────────────────────────────────────────────────────────────────┐
│  SHOP FLOOR (OT)                                                │
│  • Capteurs IoT (vibration, T°, courant)                        │
│  • Caméras industrielles (Cognex, Basler)                       │
│  • PLC / SCADA (Siemens, Schneider, Rockwell)                   │
│  • OPC-UA, Modbus, MQTT                                         │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│  EDGE COMPUTING                                                 │
│  • NVIDIA Jetson, Raspberry Pi industriel, Advantech            │
│  • Modèles ML compactés (TFLite, ONNX)                          │
│  • Bufferisation locale (en cas de coupure réseau)              │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│  INGESTION                                                      │
│  • Kafka / RabbitMQ                                             │
│  • Telegraf → InfluxDB / TimescaleDB                            │
└─────────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┼────────────────┐
              ▼               ▼                ▼
        ┌──────────┐    ┌──────────┐     ┌──────────┐
        │   ML     │    │   LLM    │     │  VISION  │
        │          │    │          │     │          │
        │ Anomaly  │    │ Mistral  │     │ YOLOv8   │
        │ detect   │    │ Large    │     │ Custom   │
        │          │    │          │     │ CNN      │
        │ Predict  │    │ Claude   │     │          │
        │ maint    │    │ Sonnet/  │     │ Mistral  │
        │ Forecast │    │ Haiku    │     │ vision   │
        │          │    │ (souvent │     │          │
        │          │    │ on-prem) │     │          │
        └──────────┘    └──────────┘     └──────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│  INTÉGRATIONS MÉTIER                                            │
│  • GMAO : Carl Source, IBM Maximo, Sage Maintenance, Bob Desk   │
│  • MES : Sopra MES, Wonderware, Apriso                          │
│  • ERP : SAP, Sage X3, Cegid, Microsoft Dynamics                │
│  • PLM : Dassault 3DEXPERIENCE, PTC Windchill, Siemens Teamcenter│
│  • Lab : MES pharma (Werum PAS-X, Tulip)                        │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│  INFRA — souvent hybride / on-prem                              │
│  • Cloud : AWS / Azure FR / Scaleway / OVHcloud                 │
│  • On-prem : Kubernetes / Docker sur serveurs propre site       │
│  • Air gap pour défense / pharma                                │
│  • Mistral self-hosted (modèles open weights) si air gap        │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│  OBSERVABILITÉ                                                  │
│  • Grafana + Prometheus (industriel)                            │
│  • Datadog (si cloud)                                           │
│  • Logs OPC-UA → tracability                                    │
└─────────────────────────────────────────────────────────────────┘

🧠 La décision qui structure toute la verticale : cloud vs on-prem pour le LLM

C'est LA question d'architecte sur l'industrie FR, et 80% des projets échouent ou se font tuer en comité sécurité parce qu'elle est mal traitée. Un AI Engineer junior répond "Mistral self-hosted parce que souverain". Un staff engineer répond en posant 3 questions : qui sont les données ?, quel est le SLA réel ?, qui paie les GPU ?

Le mental model

Tu n'as pas un choix binaire "cloud vs on-prem". Tu as un gradient de confidentialité et un gradient de capacité, et ils tirent en sens inverse :

Option	Confidentialité	Capacité modèle	Coût build	Coût run	Quand
Claude Opus 4.8 / Sonnet 4.6 (API)	Données sortent (FR/EU data residency possible via AWS Bedrock europe-west, ou Claude Platform on AWS région UE)	Maximale (raisonnement, vision haute-résolution, tool use)	Faible	Variable (token-based)	Docs non-sensibles, prototypage, ETI non-défense
Claude via VPC / Bedrock région UE	Données restent dans ton compte AWS UE, pas de ret' modèle	Maximale	Faible	Variable	ETI avec DPO exigeant mais pas air-gap
Mistral Large self-hosted (vLLM, GPU on-prem)	Données ne quittent jamais le site	Bonne mais < Claude Opus sur raisonnement multi-étapes	Élevé (GPU A100/H100, MLOps)	Fixe (amortissement GPU + ops)	Défense, pharma, brevets clients, air-gap réel
Mistral / Llama quantifié sur edge (llama.cpp)	Total	Faible (7-8B quantifié)	Moyen	Très faible	Edge offline, latence critique, pas de raisonnement complexe

La règle du staff engineer : ne self-host pas par réflexe. Le self-hosting LLM coûte cher (un H100 ≈ 2-3€/h en cloud, 25-30K€ à l'achat + ops + un ingé MLOps à 700€/j) et te fait porter le SLA, la sécu modèle, et le tuning. Tu ne le fais que si une contrainte dure et écrite l'impose : air-gap OT réel, classification Secret Défense, ou clause contractuelle "no data leaves the perimeter".

Pourquoi Claude est souvent le bon défaut (même en industrie FR)

Le narratif "souverain = Mistral on-prem" est vrai pour la défense et la pharma sous brevet. Mais pour la majorité des ETI manufacturières, les données techniques (modes opératoires, fiches matériel) ne sont pas plus sensibles qu'un email — et la qualité de raisonnement de Claude Opus 4.8 fait gagner des mois sur les cas durs (extraction de plans, vision sur photos de défauts, agents multi-étapes pour la maintenance). Le bon move commercial : proposer les deux, chiffrer le delta, et laisser le comité sécurité trancher avec toi en conseil — pas en fournisseur.

Faits 2026 à connaître par cœur (sinon tu te fais piéger en réunion archi) :

Claude Opus 4.8 (claude-opus-4-8) : flagship, fenêtre 1M tokens, 5 $ / 25 $ par million de tokens (entrée/sortie). Raisonnement long-horizon état de l'art, vision haute-résolution (utile pour plans/défauts).
Claude Sonnet 4.6 (claude-sonnet-4-6) : le bon rapport vitesse/intelligence pour l'assistant opérateur temps réel.
Claude Haiku 4.5 (claude-haiku-4-5) : 1 $ / 5 $ par million de tokens, pour le classement/routage à haut volume (ex : trier 100K tickets GMAO).
Pas de budget_tokens : sur Opus 4.8 (et la génération 4.x récente), la forme thinking: {type: "enabled", budget_tokens: N} retourne un HTTP 400. On utilise le thinking adaptatif (thinking: {type: "adaptive"}) + output_config.effort (low/medium/high). Sonnet 4.6 et Haiku 4.5 ne prennent pas de budget de réflexion. C'est exactement le genre de détail qui te fait passer pour quelqu'un qui a réellement mis du Claude en prod.
Prompt caching : sur les pipelines RAG industriels, le prompt système + la liste d'outils sont stables → mets un cache_control sur le préfixe stable, tu divises le coût d'entrée par ~10 sur les tokens cachés. Sur 50 techniciens qui posent 30 questions/jour, ça change le P&L du run.

Architecture hybride de référence (ce que tu vends vraiment)

Routage par sensibilité, pas par défaut :

  Question opérateur ──► classifier (Haiku 4.5, cheap)
                              │
            ┌─────────────────┼──────────────────┐
            ▼                 ▼                  ▼
   doc PUBLIC/interne   doc CONFIDENTIEL    doc CLASSIFIÉ
            │                 │                  │
     Claude Sonnet 4.6   Claude via VPC      Mistral on-prem
     (API, rapide)       Bedrock UE          (air-gap)
            │                 │                  │
            └─────────────────┴──────────────────┘
                              ▼
                  RAG citations + audit log (usage, coût)

Le classifier de sensibilité est le composant que personne ne code et qui fait toute la différence en comité sécurité : il garantit qu'une fiche brevet client ne partira jamais vers une API externe, par construction. C'est ton argument anti-fuite, et c'est testable (cf. exercices).

Exemple — appel Claude côté serveur, production-grade (Python)

Si tu intègres Claude (cas ETI non-défense, le plus fréquent), voici la forme attendue d'un senior — AsyncAnthropic, retries SDK + exceptions typées, timeout, streaming, logging du coût, et le prompt caching sur le préfixe stable :

python

# industry/rag/claude_answer.py
from __future__ import annotations

import logging

from anthropic import (
    AsyncAnthropic,
    APITimeoutError,
    RateLimitError,
    APIStatusError,
)

LOG = logging.getLogger(__name__)

# Le client gère retries (backoff exponentiel) + timeout par appel.
client = AsyncAnthropic(max_retries=4)

SYSTEM_PROMPT = """Tu es l'assistant maintenance de MécaPrécise.
Tu réponds UNIQUEMENT à partir du contexte fourni.
Si le contexte ne contient pas la réponse, dis-le explicitement et propose
d'escalader vers un expert. Tu cites systématiquement les sources (titre + page).
Ton de l'atelier : concis, étapes numérotées si procédure, français professionnel."""


async def answer_with_claude(question: str, context: str) -> tuple[str, dict]:
    """Retourne (réponse, usage) ; lève une exception typée en cas d'échec dur."""
    try:
        resp = await client.messages.create(
            model="claude-sonnet-4-6",  # Sonnet 4.6 : bon compromis latence/qualité atelier
            max_tokens=1024,
            timeout=30.0,
            thinking={"type": "adaptive"},          # PAS de budget_tokens (400 sur 4.x récents)
            output_config={"effort": "medium"},     # low | medium | high
            system=[
                {
                    "type": "text",
                    "text": SYSTEM_PROMPT,
                    # Préfixe stable → caché. Sur N techniciens, coût d'entrée /~10.
                    "cache_control": {"type": "ephemeral"},
                }
            ],
            messages=[
                {
                    "role": "user",
                    "content": f"Question : {question}\n\nContexte :\n{context}",
                }
            ],
        )
    except RateLimitError:
        LOG.warning("Rate limit Claude — bascule file d'attente / fallback Mistral")
        raise
    except (APITimeoutError, APIStatusError) as e:
        LOG.exception("Échec appel Claude : %s", e)
        raise

    if resp.stop_reason == "refusal":
        # Toujours vérifier stop_reason AVANT de lire le contenu.
        return ("Je ne peux pas répondre à cette demande.", {})

    text = "".join(b.text for b in resp.content if b.type == "text")
    # Logger l'usage = piloter le coût en run (argument P&L vital pour la PME).
    usage = {
        "input": resp.usage.input_tokens,
        "cached": resp.usage.cache_read_input_tokens,
        "output": resp.usage.output_tokens,
    }
    LOG.info("Claude usage: %s", usage)
    return text, usage

Note de cohérence : dans les deux cas d'usage END-TO-END plus bas, le code montre une stack Mistral self-hosted (scénario air-gap aéronautique/agroalimentaire). C'est délibéré — c'est le scénario où l'on doit self-host. Le bloc Claude ci-dessus est ce que tu déploies pour les ~70% d'ETI où l'air-gap n'est pas une contrainte réelle. Sache vendre les deux et défendre le choix.

💰 Pricing & business model

TJM réaliste 2026

Profil	TJM	Conditions
Junior industriel	500-700€	rare en freelance
AI Engineer généraliste	700-900€	PME industrielle
AI Engineer Industrie (toi année 1)	800-1100€	1-2 missions, OPC-UA familier
AI Engineer Industrie sénior	1100-1300€	référence grand groupe
AI Engineer défense/aéro habilité	1300-1600€	habilitation Secret / Très Secret, rare

Missions types

AI Audit (5-8j, 8-12K€) — souvent sur site, multi-jour
AI POC (15-25j, 22-35K€) — un use case ciblé, parfois subventionné BPI
AI Production (60-120j, 80-180K€) — industrialisation
Régie longue (12-18 mois, 950-1150€/j) — embed équipe digital
AI Engineer fractionnel PME : 4 jours/mois × 950€ × 12 = 45K€/an (très accessible PME)
MRR SaaS verticalisé : ex "MaintScan" white-label maintenance prédictive 999-2999€/mois/ligne

Mix recommandé année 1 freelance Industrie

2 audits (20K€)
1 POC subventionné BPI (30K€ payé par client, jusqu'à 50% via BPI)
1 régie 6 mois 1000€/j (120K€)
1 mission production (90K€)
= ~260K€ HT (cycle de vente lent : tu décroches en S6-12)
Année 2-3 : 350-450K€ HT avec MRR SaaS en parallèle.

📚 Cas d'usage 1 — END-TO-END : RAG documentation technique + assistant maintenance

Contexte client

Cible : "MécaPrécise" (fictif), ETI mécanique de précision Vallée de l'Arve, 380 salariés, 5 sites France + Maroc, CA 95M€. Spécialité : décolletage aéronautique.

Pain :

12 ans de docs techniques accumulés (50K+ fichiers Word/PDF/AutoCAD)
Départ retraite de 8 anciens techniciens dans 18 mois → perte savoir-faire critique
Nouveau technicien passe 4-6h/jour à chercher des infos

Demande : "Capture le savoir-faire dans un assistant que tout technicien peut interroger en français, sur tablette industrielle, même en mode air-gap."

Brief commercial

Budget : 150K€ build + 50K€/an run, dont 60K€ subventionnés via dispositif BPI "PME 4.0"
Délai : 6 mois (POC 8 semaines, 5 sites en cascade)
Contraintes : hébergement on-prem (data sensible, brevets clients aéro), Mistral self-hosted ou Scaleway dédié, fonctionnement offline 24h
Critères succès : 80% techniciens utilisateurs hebdo, -40% temps de recherche, capitalisation interviews retraités

Solution architecture

┌──────────────────────────────────────────────────────┐
│  SOURCES                                             │
│  • SharePoint (50K fichiers)                         │
│  • PLM Dassault (modes opératoires)                  │
│  • Photos atelier annotées (10 ans)                  │
│  • Interviews retraités (audio FR transcrit)         │
└──────────────┬───────────────────────────────────────┘
               ▼
┌──────────────────────────────────────────────────────┐
│  Pipeline ingestion (Airflow)                        │
│  - OCR PDF (Mistral OCR on-prem ou Tesseract)        │
│  - Extraction métadonnées (machine, opération, mat.) │
│  - Chunking par section logique                      │
│  - Embedding (multilingual-e5-large self-host)       │
│  - Upsert Qdrant + index Postgres                    │
└──────────────┬───────────────────────────────────────┘
               ▼
┌──────────────────────────────────────────────────────┐
│  Couche RAG                                          │
│  - Hybrid search (BM25 + dense)                      │
│  - Filtres : machine, type opération, matière        │
│  - LLM : Mistral Large 2 self-hosted (GPU on-prem)   │
│  - Citations vers source + page                      │
└──────────────┬───────────────────────────────────────┘
               ▼
┌──────────────────────────────────────────────────────┐
│  Interface tablette industrielle (PWA + native)      │
│  - Recherche textuelle ou vocale                     │
│  - QR code scan (référence pièce) → contexte auto    │
│  - Mode "offline 24h" (cache local)                  │
└──────────────────────────────────────────────────────┘

Code samples

1. Ingestion docs techniques (Python)

python

# industry/rag/ingest.py
from __future__ import annotations

import asyncio
import hashlib
import logging
import re
from dataclasses import dataclass
from pathlib import Path

import httpx
from qdrant_client import AsyncQdrantClient
from qdrant_client.http.models import Distance, PointStruct, VectorParams

LOG = logging.getLogger(__name__)

COLLECTION = "tech_docs"


@dataclass
class DocChunk:
    doc_id: str
    chunk_idx: int
    title: str
    content: str
    metadata: dict


def chunk_text(text: str, max_words: int = 600, overlap: int = 50) -> list[str]:
    words = text.split()
    if len(words) <= max_words:
        return [text]
    chunks = []
    step = max_words - overlap
    for i in range(0, len(words), step):
        chunks.append(" ".join(words[i : i + max_words]))
        if i + max_words >= len(words):
            break
    return chunks


def extract_metadata(filename: str, content: str) -> dict:
    """Extrait métadonnées d'un mode opératoire mécanique."""
    md: dict = {"source_file": filename}
    # Référence machine
    m = re.search(r"\b(Mazak|Citizen|Tornos|Star|Doosan|DMG)\s*[A-Z0-9\-]+", content)
    if m:
        md["machine"] = m.group(0)
    # Type opération
    for op in ["décolletage", "tournage", "fraisage", "ébavurage", "polissage"]:
        if op in content.lower():
            md.setdefault("operations", []).append(op)
    # Matière
    for mat in ["inox", "316L", "Ti6Al4V", "AW2024", "PEEK", "aluminium"]:
        if mat.lower() in content.lower():
            md.setdefault("materials", []).append(mat)
    return md


async def embed_batch(texts: list[str], embed_url: str) -> list[list[float]]:
    """Mistral embeddings on-prem (self-hosted)."""
    async with httpx.AsyncClient(timeout=120) as c:
        resp = await c.post(
            embed_url,
            json={"input": texts, "model": "multilingual-e5-large"},
        )
        return [r["embedding"] for r in resp.json()["data"]]


async def ingest_file(
    path: Path,
    qdrant: AsyncQdrantClient,
    embed_url: str,
    extract_text_fn,
) -> int:
    text = await extract_text_fn(path)
    if not text:
        return 0
    md = extract_metadata(path.name, text)
    chunks = chunk_text(text)
    doc_id = hashlib.sha256(str(path).encode()).hexdigest()[:16]
    embeddings = await embed_batch(chunks, embed_url)
    points = [
        PointStruct(
            id=f"{doc_id}-{i}",
            vector=v,
            payload={
                "doc_id": doc_id,
                "chunk_idx": i,
                "title": path.stem,
                "content": c,
                **md,
            },
        )
        for i, (c, v) in enumerate(zip(chunks, embeddings))
    ]
    await qdrant.upsert(collection_name=COLLECTION, points=points)
    return len(points)


async def ensure_collection(qdrant: AsyncQdrantClient, dim: int = 1024) -> None:
    cols = (await qdrant.get_collections()).collections
    if not any(c.name == COLLECTION for c in cols):
        await qdrant.create_collection(
            collection_name=COLLECTION,
            vectors_config=VectorParams(size=dim, distance=Distance.COSINE),
        )


async def ingest_directory(root: Path, qdrant_url: str, embed_url: str, extract_fn):
    qdrant = AsyncQdrantClient(url=qdrant_url)
    await ensure_collection(qdrant)
    files = [p for p in root.rglob("*") if p.suffix.lower() in {".pdf", ".docx", ".txt"}]
    LOG.info("Ingesting %d files", len(files))
    total = 0
    for f in files:
        try:
            n = await ingest_file(f, qdrant, embed_url, extract_fn)
            total += n
        except Exception as e:
            LOG.exception("Failed ingesting %s: %s", f, e)
    LOG.info("Total chunks: %d", total)

2. RAG retrieval + génération (Python)

python

# industry/rag/query.py
from __future__ import annotations

from dataclasses import dataclass

import httpx
from qdrant_client import AsyncQdrantClient
from qdrant_client.http.models import Filter, FieldCondition, MatchAny

COLLECTION = "tech_docs"


@dataclass
class QueryResult:
    answer: str
    citations: list[dict]
    confidence: float


SYSTEM_PROMPT = """Tu es l'assistant maintenance de MécaPrécise.
Tu réponds UNIQUEMENT à partir du contexte fourni.
Si le contexte ne contient pas la réponse, dis "Je n'ai pas trouvé cette information
dans la documentation. Voulez-vous que je transmette la question à un expert ?"
Tu cites systématiquement les sources avec leur titre.
Format : réponse claire, étapes numérotées si procédure.
Tu écris en français professionnel, ton de l'atelier (concis, sans bla-bla)."""


async def embed(text: str, embed_url: str) -> list[float]:
    async with httpx.AsyncClient(timeout=30) as c:
        resp = await c.post(
            embed_url,
            json={"input": [text], "model": "multilingual-e5-large"},
        )
        return resp.json()["data"][0]["embedding"]


async def llm_complete(
    system: str, user: str, llm_url: str, model: str = "mistral-large"
) -> str:
    async with httpx.AsyncClient(timeout=120) as c:
        resp = await c.post(
            llm_url,
            json={
                "model": model,
                "messages": [
                    {"role": "system", "content": system},
                    {"role": "user", "content": user},
                ],
                "temperature": 0.2,
                "max_tokens": 800,
            },
        )
        return resp.json()["choices"][0]["message"]["content"]


async def answer_question(
    question: str,
    qdrant_url: str,
    embed_url: str,
    llm_url: str,
    machine: str | None = None,
    material: str | None = None,
) -> QueryResult:
    qdrant = AsyncQdrantClient(url=qdrant_url)
    vec = await embed(question, embed_url)
    must = []
    if machine:
        must.append(FieldCondition(key="machine", match=MatchAny(any=[machine])))
    if material:
        must.append(FieldCondition(key="materials", match=MatchAny(any=[material])))
    filt = Filter(must=must) if must else None
    hits = await qdrant.search(
        collection_name=COLLECTION,
        query_vector=vec,
        query_filter=filt,
        limit=6,
        with_payload=True,
    )
    if not hits or hits[0].score < 0.35:
        return QueryResult(
            answer="Je n'ai pas trouvé d'information fiable dans la documentation.",
            citations=[],
            confidence=hits[0].score if hits else 0.0,
        )
    context = "\n\n".join(
        f"[Source {i+1}: {h.payload['title']}]\n{h.payload['content']}"
        for i, h in enumerate(hits)
    )
    user_prompt = f"Question : {question}\n\nContexte:\n{context}"
    answer = await llm_complete(SYSTEM_PROMPT, user_prompt, llm_url)
    citations = [
        {"title": h.payload["title"], "score": h.score, "source": h.payload.get("source_file")}
        for h in hits[:3]
    ]
    return QueryResult(answer=answer, citations=citations, confidence=hits[0].score)

3. Interface tablette PWA (TypeScript / Next.js)

// industry/tablet-ui/app/page.tsx
"use client";

import { useEffect, useRef, useState } from "react";

interface Citation {
  title: string;
  score: number;
  source: string | null;
}

interface AnswerResponse {
  answer: string;
  citations: Citation[];
  confidence: number;
}

export default function MaintenanceAssistantPage() {
  const [question, setQuestion] = useState("");
  const [answer, setAnswer] = useState<AnswerResponse | null>(null);
  const [loading, setLoading] = useState(false);
  const [machineRef, setMachineRef] = useState<string | null>(null);
  const [voiceActive, setVoiceActive] = useState(false);
  const recognitionRef = useRef<any>(null);

  // QR scan → machine ref (via cam)
  useEffect(() => {
    const url = new URL(window.location.href);
    const ref = url.searchParams.get("machine");
    if (ref) setMachineRef(ref);
  }, []);

  // Speech recognition (Web Speech API)
  function startVoice() {
    const SpeechRecognition =
      (window as any).webkitSpeechRecognition ||
      (window as any).SpeechRecognition;
    if (!SpeechRecognition) {
      alert("Reconnaissance vocale non supportée sur cette tablette.");
      return;
    }
    const rec = new SpeechRecognition();
    rec.lang = "fr-FR";
    rec.continuous = false;
    rec.interimResults = false;
    rec.onresult = (e: any) => {
      const transcript = e.results[0][0].transcript;
      setQuestion(transcript);
      submit(transcript);
    };
    rec.onend = () => setVoiceActive(false);
    recognitionRef.current = rec;
    setVoiceActive(true);
    rec.start();
  }

  async function submit(qOverride?: string) {
    const q = qOverride ?? question;
    if (!q.trim()) return;
    setLoading(true);
    setAnswer(null);
    try {
      const resp = await fetch("/api/ask", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ question: q, machine: machineRef }),
      });
      const data: AnswerResponse = await resp.json();
      setAnswer(data);
      // Cache local pour mode offline 24h
      localStorage.setItem(
        `cache:${q}`,
        JSON.stringify({ data, ts: Date.now() })
      );
    } catch (e) {
      // fallback cache
      const cached = localStorage.getItem(`cache:${q}`);
      if (cached) {
        const { data } = JSON.parse(cached);
        setAnswer({ ...data, answer: data.answer + "\n\n[Mode offline — cache]" });
      }
    } finally {
      setLoading(false);
    }
  }

  return (
    <main className="min-h-screen p-6 bg-gray-100">
      <h1 className="text-2xl font-bold mb-2">Assistant maintenance</h1>
      {machineRef && <p className="mb-4 text-sm">Machine : {machineRef}</p>}
      <textarea
        className="w-full p-3 border rounded text-lg"
        rows={3}
        value={question}
        onChange={(e) => setQuestion(e.target.value)}
        placeholder="Posez votre question (ex: changement plaquette inox)"
      />
      <div className="flex gap-2 mt-2">
        <button
          className="flex-1 bg-blue-600 text-white py-3 rounded text-lg"
          onClick={() => submit()}
          disabled={loading}
        >
          {loading ? "..." : "Rechercher"}
        </button>
        <button
          className={`px-6 py-3 rounded text-white text-lg ${
            voiceActive ? "bg-red-600" : "bg-gray-700"
          }`}
          onClick={startVoice}
        >
          {voiceActive ? "..." : "Voix"}
        </button>
      </div>
      {answer && (
        <div className="mt-6 bg-white p-4 rounded shadow">
          <p className="whitespace-pre-line text-lg">{answer.answer}</p>
          {answer.citations.length > 0 && (
            <div className="mt-4">
              <h3 className="font-semibold">Sources :</h3>
              <ul>
                {answer.citations.map((c, i) => (
                  <li key={i} className="text-sm">
                    {c.title} ({c.source}) — confiance {(c.score * 100).toFixed(0)}%
                  </li>
                ))}
              </ul>
            </div>
          )}
        </div>
      )}
    </main>
  );
}

ROI mesuré

KPI	Avant	Après	Gain
Temps recherche/jour/technicien	2h30	50 min	-67%
Délai intervention moyen	4h	2h30	-38%
Taux usage hebdo techniciens	n/a	91%	adoption
Procédures capturées (interviews retraités)	0	47	savoir-faire
Économies annuelles	—	—	~420 K€

Solution facturée : 150K€ build + 50K€/an run (60K€ subventionnés BPI PME 4.0).

📚 Cas d'usage 2 — END-TO-END : Assistant production opérateur ligne (mobile + voice)

Contexte client

Cible : "AgroTrans" (fictif), agroalimentaire, 6 sites FR, 1200 opérateurs ligne, ligne IFS / BRC.

Pain :

30% turnover opérateurs/an → formation continue
Erreurs qualité dues aux nouveaux opérateurs
Procédures qualité dispersées (Word, intranet, affichage atelier)

Demande : "Donne à chaque opérateur un assistant vocal qui rappelle la procédure du poste, identifie les défauts en photo, et déclenche une fiche incident si besoin."

Solution architecture

Tablette industrielle au poste (étanche, IP65)
Opérateur scanne QR code poste → contexte chargé (recettes en cours, procédures, contacts)
Question vocale ou tap → assistant LLM répond
Photo défaut → Mistral Vision analyse → si défaut majeur, fiche incident auto créée dans GMAO
Statistiques quotidiennes : nb questions, défauts, temps d'arrêt

Code samples

1. Détection défaut produit par vision (Python — Mistral Vision)

python

# industry/quality/vision_inspector.py
from __future__ import annotations

import base64
from dataclasses import dataclass
from enum import Enum
from pathlib import Path

import httpx


class Severity(str, Enum):
    OK = "ok"
    MINOR = "minor"
    MAJOR = "major"


@dataclass
class DefectAnalysis:
    severity: Severity
    defect_types: list[str]
    description: str
    requires_stop: bool
    suggested_action: str


SYSTEM = """Tu es un inspecteur qualité agroalimentaire. Tu analyses une photo
d'un produit en sortie de ligne. Tu identifies les défauts visibles et leur sévérité.

Sévérité :
- ok : pas de défaut visible
- minor : défaut esthétique (étiquette de travers, légère bavure)
- major : défaut critique (corps étranger, hygiène, allergène visible, scellé brisé)

Si MAJOR : tu indiques requires_stop = true.

Format JSON strict:
{"severity": "...", "defect_types": [...], "description": "...",
 "requires_stop": bool, "suggested_action": "..."}"""


async def inspect_product(
    image_bytes: bytes,
    product_ref: str,
    line_id: str,
    llm_url: str,
    api_key: str,
) -> DefectAnalysis:
    b64 = base64.b64encode(image_bytes).decode()
    payload = {
        "model": "mistral-large-latest",
        "messages": [
            {"role": "system", "content": SYSTEM},
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
                    },
                    {
                        "type": "text",
                        "text": f"Produit: {product_ref}. Ligne: {line_id}. Analyse cette photo.",
                    },
                ],
            }
        ],
        "response_format": {"type": "json_object"},
        "temperature": 0.1,
        "max_tokens": 600,
    }
    async with httpx.AsyncClient(timeout=60) as c:
        resp = await c.post(
            llm_url,
            headers={"Authorization": f"Bearer {api_key}"},
            json=payload,
        )
    import json

    data = json.loads(resp.json()["choices"][0]["message"]["content"])
    return DefectAnalysis(
        severity=Severity(data["severity"]),
        defect_types=data.get("defect_types", []),
        description=data["description"],
        requires_stop=bool(data.get("requires_stop", False)),
        suggested_action=data.get("suggested_action", ""),
    )

2. Création fiche incident GMAO (TypeScript)

// industry/quality/gmao-client.service.ts
import { Injectable } from "@nestjs/common";
import axios from "axios";

interface IncidentInput {
  lineId: string;
  productRef: string;
  defectTypes: string[];
  severity: "minor" | "major";
  description: string;
  reportedByOperatorId: string;
  imageUrl: string;
}

@Injectable()
export class GmaoClientService {
  private readonly api = axios.create({
    baseURL: process.env.CARL_SOURCE_URL,
    headers: {
      Authorization: `Bearer ${process.env.CARL_SOURCE_TOKEN}`,
    },
  });

  async createIncident(input: IncidentInput): Promise<{ id: string; url: string }> {
    const resp = await this.api.post("/api/v2/work-orders", {
      title: `Défaut ${input.severity.toUpperCase()} — ${input.productRef}`,
      description: input.description,
      priority: input.severity === "major" ? "URGENT" : "NORMAL",
      asset_id: input.lineId,
      type: "QUALITY_INCIDENT",
      reported_by: input.reportedByOperatorId,
      attachments: [{ url: input.imageUrl, type: "image" }],
      custom_fields: {
        defect_types: input.defectTypes.join(", "),
        product_ref: input.productRef,
      },
    });
    return { id: resp.data.id, url: resp.data.url };
  }

  async stopLine(lineId: string, reason: string): Promise<void> {
    await this.api.post(`/api/v2/assets/${lineId}/stop`, { reason });
  }
}

ROI mesuré

KPI	Avant	Après	Gain
Temps formation nouvel opérateur (à autonomie)	4 mois	6 semaines	-65%
Défauts qualité critiques	0.8%	0.18%	-77%
Temps moyen création fiche incident	12 min	45 sec	-94%
Taux d'usage hebdo opérateurs	n/a	87%	adoption

Solution facturée : 180K€ build + 60K€/an + équipement tablettes refacturé séparément.

⚖️ Réglementation française / EU

RGPD industrie

Données opérateurs (vidéo, voix, geo) = sensible → DPIA
Vidéosurveillance lignes : déclaration CNIL + information opérateurs

Code du travail

L. 2312-38 — consultation CSE pour outils numériques
Surveillance électronique (article 1121-1) — proportionnalité

Secret industriel / brevets

Pas exporter données hors entreprise (LLM cloud)
Préfère Mistral self-hosted ou Scaleway souverain

AI Act

Industrie : généralement pas high-risk
Sauf : machines à dommages aux personnes (annexe I) — équipements sous directive machines

Normes industrie

ISO 9001 (qualité), ISO 14001 (env), ISO 45001 (sécurité), ISO 27001 (info)
IFS / BRC / FSSC 22000 (agroalimentaire)
ATEX (explosion), CE marking

Défense / dual-use

Habilitation niveau Secret / Très Secret (réforme 2021 : "Confidentiel Défense" supprimé, remplacé par classification à deux niveaux)
ITAR si tu touches à US defense
BPI / DGA accompagnement

Réindustrialisation et subventions

France 2030, BPI "Plan PME 4.0", appels à projets ADEME
30-50% subvention possible sur IA industrie

🏆 Concurrents / acteurs établis

Type	Acteur	Force	Différenciation
ESN industrie	Sopra Steria, Capgemini, Atos	Volume	Toi = freelance, plus rapide, moins cher
AI vision industrie	Cognex, Keyence	Hardware + soft	Toi = soft custom + LLM moderne
Maintenance prédictive	C3.ai (US), Augury, Senseye	Verticale	Toi = sur-mesure + Mistral souverain
GMAO	Carl Source, IBM Maximo, Coswin	Marché legacy	Toi = couche IA dessus
Dassault Systèmes	3DEXPERIENCE, Delmia	Très mature	Toi = complément ou intégration

Différenciation

Freelance + agile + souverain : tu rassures (pas de fuite données vers US)
Mistral self-hosted : avantage clé pour défense / pharma
Mobile + voice + tablette industrielle : tu vis dans l'atelier, pas dans une slide
Subventions BPI / ADEME : tu sais structurer un dossier pour 30-50% de remise

🎤 Pitch deck / proposition commerciale

Email type prospection (DSI / Directeur Production / Directeur Industriel ETI)

Sujet : -30% temps recherche docs technique en 6 mois — POC subventionné BPI

Bonjour [Prénom],

Vos techniciens passent 30-50% de leur temps à chercher des informations
dans la documentation. Vos anciens partent à la retraite. Le savoir-faire fuit.

Je suis AI Engineer industrie, je sais capturer ça dans un assistant IA
intégré sur tablette (français, voix, offline, on-prem).

3 résultats que j'apporte aux ETI industrielles FR en 2026 :

1. RAG documentation technique (Mistral self-hosted, on-prem)
2. Assistant opérateur production (voix, photos défauts, fiche incident GMAO)
3. Subvention BPI / France 2030 (jusqu'à 50% du POC)

Référence : [Anonyme], 380 salariés, -67% temps recherche, économies 420K€/an.

Audit sur site 5 jours, 9K€. POC 15 jours, 22K€ (50% BPI sous conditions).

RDV sur site ou visio la semaine prochaine ?

Cordialement,
[Prénom Nom]
AI Engineer | Industrie | Vallée de l'Arve / Paris

3 templates LinkedIn

Educatif : "Pourquoi 80% des projets IA industriels échouent en France (et les 4 conditions de succès)"
Cas client : "Comment une ETI mécanique a capturé 47 procédures de techniciens partis à la retraite en 4 mois"
Provocateur : "Vous achetez du C3.ai à 500K€/an. Vous pouvez avoir mieux pour 150K€ build + 50K€/an. Voici comment."

🚀 Plan d'attaque 90 jours

Mois 1

S1 : LinkedIn refonte "AI Engineer Industrie | RAG technique + Mistral on-prem | FR"
S2 : Comprendre BPI dispositifs ("PME 4.0", "Industrie du Futur"), France 2030
S3 : POC public : démo RAG mécanique (notebooks + vidéo)
S4 : 1er article LinkedIn "Pourquoi 80% IA industrielle échoue"

Mois 2

S5-6 : Cibler 100 ETI industrielles (mouvement METI, France Industrie)
S7-8 : Aller à Global Industrie (Lyon, mars/avril) → networking massif. C'est LE event
Partenariat avec un CETIM ou pôle de compétitivité local

Mois 3

S9-10 : 1 audit sur site signé (10K€, 7 jours)
S11-12 : Préparer dossier BPI / France 2030 avec client (gratuit, mais argument vendeur)
POC signé

Objectif fin S12 : 25-40K€ HT facturé, dossier BPI déposé, présence Global Industrie consolidée.

🏋️ Exercices

Difficulté croissante. Les premiers se codent en une soirée, les derniers sont des sujets de mission. Le but n'est pas "ça marche en démo" mais "ça tient en comité sécurité / en run / sous charge". Fais-les dans l'ordre.

Exercice 1 — Routeur de sensibilité (le composant qui sauve les projets)

Objectif : coder un classifier qui décide, pour chaque requête, vers quel backend LLM elle part (Claude API / Claude VPC / Mistral on-prem), de sorte qu'un document classifié ne puisse jamais sortir du périmètre.

Indice/Solution : un appel Claude Haiku 4.5 (cheap, rapide) avec sortie structurée (via output_config.format) renvoyant un objet sensitivity (valeurs public / internal / confidential / classified) plus un rationale. Mappe classified → Mistral on-prem en dur. Le test qui compte : un golden set de 50 docs étiquetés à la main + une assertion fail-closed — si le classifier hésite ou erreur, on route vers le backend le plus restrictif, pas le plus permissif. Mesure précision/rappel sur la classe classified séparément (un faux négatif y est une fuite, pas une stat).

Exercice 2 — RAG offline-first sur tablette industrielle

Objectif : rendre l'assistant maintenance utilisable 24h sans réseau (coupure shop floor), avec dégradation gracieuse plutôt que page blanche.

Indice/Solution : cache local (IndexedDB/SQLite) des N dernières Q&A + un index vectoriel embarqué léger (les 500 procédures les plus consultées, embeddings pré-calculés). En offline, on répond depuis le cache et on affiche explicitement "mode offline — réponse du cache du JJ/MM". Le piège senior : ne pas servir une réponse périmée comme si elle était fraîche (une procédure de sécurité modifiée = accident). Ajoute un TTL et un bandeau de péremption.

Exercice 3 — Pilotage du coût en run (défends le chiffre)

Objectif : instrumenter le pipeline RAG pour que tu puisses dire à un DAF, à l'euro près, ce que coûte 1 000 questions techniciens — et le faire baisser de 60% sans perte de qualité.

Indice/Solution : logge resp.usage (input / cache_read_input_tokens / output) à chaque appel. Calcule au prix réel : Sonnet 4.6 à 3 $/15 $ par M tokens, Haiku 4.5 à 1 $/5 $. Puis applique les 3 leviers : (1) prompt caching sur le préfixe système+contexte stable (coût d'entrée caché ≈ 0,1×), (2) routage Haiku pour les questions triviales (FAQ), Sonnet seulement pour les cas durs, (3) effort adaptatif au lieu de max partout. Présente un avant/après chiffré. Tu dois pouvoir défendre chaque ligne en réunion.

Exercice 4 — Casse-le puis répare-le : empoisonnement de la base RAG

Objectif : démontrer puis corriger une faille de confiance — un technicien malveillant (ou une OCR foireuse) injecte une procédure erronée qui se propage dans les réponses.

Indice/Solution : ajoute un chunk piège ("pour purger la ligne, ouvrir la vanne X sans consignation") et observe l'assistant le restituer avec une fausse autorité. Répare avec : provenance signée par source (hash + auteur + date de validation), un score de confiance qui pénalise les sources non validées, et un guardrail — toute réponse touchant à la sécurité (consignation, ATEX, EPI) exige une citation vers un document validé, sinon escalade humaine forcée. C'est la différence entre un gadget et un outil utilisable sur une ligne.

Exercice 5 — Vision défaut production-grade avec boucle d'apprentissage

Objectif : passer du POC "Claude/Mistral Vision détecte un défaut sur une photo" à un système qui s'améliore et dont on connaît le taux de faux négatifs en production.

Indice/Solution : pipeline = capture → inférence vision (Claude Opus 4.8 haute-résolution pour les cas ambigus, modèle YOLO edge pour le volume) → si severity=major, fiche incident GMAO + rétention de l'image annotée. Boucle : échantillonne 1% des "ok" pour relecture humaine → mesure le faux négatif réel (le KPI qui tue : un défaut majeur non détecté = rappel produit). Versionne le modèle (MLflow) et garde un jeu de validation gelé pour détecter la dérive. Defends le chiffre "−90% de défauts non détectés" : d'où sort-il, sur quel échantillon, avec quel intervalle de confiance ?

Exercice 6 — Agent maintenance multi-étapes sous contrainte air-gap (sujet de mission)

Objectif : concevoir un agent qui, sur incident, lit la doc, interroge la GMAO, propose un plan d'intervention et génère le bon de travail — sans aucune action irréversible sans validation humaine.

Indice/Solution : boucle d'outils (tool use) avec outils dédiés (read_doc, query_gmao, create_work_order) plutôt qu'un bash générique — pour pouvoir gater create_work_order derrière une confirmation. asyncio.gather pour paralléliser les lectures doc indépendantes. Le sujet dur : faire tourner ça en air-gap signifie Mistral on-prem comme moteur d'agent → mesure la dégradation de qualité du planning vs Claude Opus 4.8, et décide si elle est acceptable. Observabilité : trace chaque appel d'outil, le coût/latence, et un mode "dry-run" où l'agent explique son plan sans rien écrire. C'est exactement ce qu'un industriel exige avant de laisser une IA toucher à sa GMAO de production.

🎤 En entretien

Questions que cette verticale provoque, et la réponse de senior en une ligne.

« Pourquoi ne pas tout faire en Mistral on-prem, puisque c'est souverain ? » Parce que le self-hosting porte le SLA, la sécu modèle et le coût GPU sur tes épaules ; on ne le fait que sous contrainte dure et écrite (air-gap réel, classification Défense), sinon Claude via Bedrock UE donne meilleure qualité, data residency UE, et un coût variable qui colle à l'usage.

« Comment garantis-tu qu'une donnée brevet client ne fuite jamais vers une API externe ? » Par un routeur de sensibilité fail-closed en amont : un classifier route classified vers le backend on-prem par construction, le test critique mesure le rappel sur la classe sensible (un faux négatif est une fuite), et en cas de doute on route au plus restrictif.

« Ton POC coûte 0,02€ la question. À 50 techniciens × 30 questions/jour, ça fait combien à l'année, et comment tu le divises par 3 ? » ≈ 11K€/an brut ; on le casse avec prompt caching sur le préfixe stable (entrée cachée ≈ 0,1×), routage Haiku 4.5 pour le trivial et Sonnet 4.6 pour le dur, et effort adaptatif au lieu de max partout — chiffres resp.usage à l'appui, pas une estimation.

« Un industriel ne te croira pas sur un "−40% de temps de recherche". Comment tu défends le chiffre ? » Mesure baseline avant déploiement (chronométrage terrain, pas déclaratif), cohorte d'usage hebdo réelle, et A/B implicite sur les techniciens early-adopters vs le reste ; le ROI se vend sur l'économie ETP × coût chargé, avec l'hypothèse explicite et conservatrice.

🔗 Liens

Associations / fédérations

France Industrie — franceindustrie.org
METI — meti-france.fr
UIMM — uimm.fr
France Digitale (section industrie)

Acteurs publics & subventions

BPI France — bpifrance.fr (programmes Industrie du Futur, PME 4.0)
France 2030 — entreprises.gouv.fr/france-2030
DGE — entreprises.gouv.fr
ADEME (énergie / décarbonation)
CETIM — cetim.fr
Pôles de compétitivité (Aerospace Valley, Plastipolis, Mont-Blanc Industries, etc.)

Salons / événements

Global Industrie (mars/avril, Lyon) — référence industrie FR
VivaTech (juin)
Industrie du Futur (Bercy)
Maintenance Expo
Solutions PME (Bercy)
MICRONORA (microtechniques, Besançon)

Médias

L'Usine Nouvelle — usinenouvelle.com
L'Usine Digitale — usine-digitale.fr
Industrie & Technologies — industrie-techno.com
Mesures.com

Communautés

France Industrie events
LinkedIn group "Industrie 4.0 France"
Forum CETIM
CCI métiers

Lectures fondamentales

France 2030 — plan complet
Rapports France Industrie
Norme ISO 22400 (KPI manufacturing)
Référentiel "Industrie du Futur" (Bercy)
Études OPCO 2i

Stack & tools

Mistral self-hosted (vLLM, llama.cpp)
Qdrant on-prem
OPC-UA SDK (python-opcua, asyncua)
NVIDIA Jetson (edge AI)
Cognex VisionPro, Keyence CV-X (vision industrielle)
Carl Source, IBM Maximo (GMAO)

Note finale : L'industrie est la verticale la plus lente à closer (6-12 mois grand groupe) mais la plus fidèle (3-5 ans de mission post-réussite). Idéal si tu acceptes 6-9 mois de prospection avant ton 1er gros contrat. Combine cela avec un MRR SaaS verticalisé (ex : maintenance prédictive sectorielle) pour stabiliser le revenu. Les subventions BPI / France 2030 sont un argument vendeur énorme — apprends à monter un dossier, ça te transforme en "partenaire" plutôt qu'en "fournisseur".

Industrie / PME France — Playbook AI Engineer 2026 ​

🎯 Pourquoi cette verticale en 2026 ​

🗺️ Carte du marché français ​

Top 10 grands groupes industriels (cibles tier 1) ​

Tier 2 — ETI industrielles accessibles freelance ​

PME / ETI manufacturières ​

Acteurs publics & soutien ​

Associations & événements pros ​

Médias spécialisés ​

💼 Top 5 use cases AI ​

Use case 1 — Maintenance prédictive (vibration, vision, signaux) ​

Use case 2 — RAG documentation technique + assistant maintenance ​

Use case 3 — Assistant opérateur production (voice + mobile) ​

Use case 4 — Contrôle qualité par vision ​

Use case 5 — Recherche brevets + veille concurrentielle technique ​

🛠️ Stack technique typique Industrie FR ​

🧠 La décision qui structure toute la verticale : cloud vs on-prem pour le LLM ​

Le mental model ​

Pourquoi Claude est souvent le bon défaut (même en industrie FR) ​

Architecture hybride de référence (ce que tu vends vraiment) ​

Exemple — appel Claude côté serveur, production-grade (Python) ​

💰 Pricing & business model ​

TJM réaliste 2026 ​

Missions types ​

Mix recommandé année 1 freelance Industrie ​

📚 Cas d'usage 1 — END-TO-END : RAG documentation technique + assistant maintenance ​

Contexte client ​

Brief commercial ​

Solution architecture ​

Code samples ​

ROI mesuré ​

📚 Cas d'usage 2 — END-TO-END : Assistant production opérateur ligne (mobile + voice) ​

Contexte client ​

Solution architecture ​

Code samples ​

ROI mesuré ​

⚖️ Réglementation française / EU ​

RGPD industrie ​

Code du travail ​

Secret industriel / brevets ​

AI Act ​

Normes industrie ​

Défense / dual-use ​

Réindustrialisation et subventions ​

🏆 Concurrents / acteurs établis ​

Différenciation ​

🎤 Pitch deck / proposition commerciale ​

Email type prospection (DSI / Directeur Production / Directeur Industriel ETI) ​

3 templates LinkedIn ​

🚀 Plan d'attaque 90 jours ​

Mois 1 ​

Mois 2 ​

Mois 3 ​

🏋️ Exercices ​

Exercice 1 — Routeur de sensibilité (le composant qui sauve les projets) ​

Exercice 2 — RAG offline-first sur tablette industrielle ​

Exercice 3 — Pilotage du coût en run (défends le chiffre) ​

Exercice 4 — Casse-le puis répare-le : empoisonnement de la base RAG ​

Exercice 5 — Vision défaut production-grade avec boucle d'apprentissage ​

Exercice 6 — Agent maintenance multi-étapes sous contrainte air-gap (sujet de mission) ​

🎤 En entretien ​

🔗 Liens ​

Associations / fédérations ​

Acteurs publics & subventions ​

Salons / événements ​

Médias ​

Communautés ​

Lectures fondamentales ​

Stack & tools ​

Industrie / PME France — Playbook AI Engineer 2026

🎯 Pourquoi cette verticale en 2026

🗺️ Carte du marché français

Top 10 grands groupes industriels (cibles tier 1)

Tier 2 — ETI industrielles accessibles freelance

PME / ETI manufacturières

Acteurs publics & soutien

Associations & événements pros

Médias spécialisés

💼 Top 5 use cases AI

Use case 1 — Maintenance prédictive (vibration, vision, signaux)

Use case 2 — RAG documentation technique + assistant maintenance

Use case 3 — Assistant opérateur production (voice + mobile)

Use case 4 — Contrôle qualité par vision

Use case 5 — Recherche brevets + veille concurrentielle technique

🛠️ Stack technique typique Industrie FR

🧠 La décision qui structure toute la verticale : cloud vs on-prem pour le LLM

Le mental model

Pourquoi Claude est souvent le bon défaut (même en industrie FR)

Architecture hybride de référence (ce que tu vends vraiment)

Exemple — appel Claude côté serveur, production-grade (Python)

💰 Pricing & business model

TJM réaliste 2026

Missions types

Mix recommandé année 1 freelance Industrie

📚 Cas d'usage 1 — END-TO-END : RAG documentation technique + assistant maintenance

Contexte client

Brief commercial

Solution architecture

Code samples

ROI mesuré

📚 Cas d'usage 2 — END-TO-END : Assistant production opérateur ligne (mobile + voice)

Contexte client

Solution architecture

Code samples

ROI mesuré

⚖️ Réglementation française / EU

RGPD industrie

Code du travail

Secret industriel / brevets

AI Act

Normes industrie

Défense / dual-use

Réindustrialisation et subventions

🏆 Concurrents / acteurs établis

Différenciation

🎤 Pitch deck / proposition commerciale

Email type prospection (DSI / Directeur Production / Directeur Industriel ETI)

3 templates LinkedIn

🚀 Plan d'attaque 90 jours

Mois 1

Mois 2

Mois 3

🏋️ Exercices

Exercice 1 — Routeur de sensibilité (le composant qui sauve les projets)

Exercice 2 — RAG offline-first sur tablette industrielle

Exercice 3 — Pilotage du coût en run (défends le chiffre)

Exercice 4 — Casse-le puis répare-le : empoisonnement de la base RAG

Exercice 5 — Vision défaut production-grade avec boucle d'apprentissage

Exercice 6 — Agent maintenance multi-étapes sous contrainte air-gap (sujet de mission)

🎤 En entretien

🔗 Liens

Associations / fédérations

Acteurs publics & subventions

Salons / événements

Médias

Communautés

Lectures fondamentales

Stack & tools