Ce week-end, j'ai retravaillé un vieux projet perso. Pas pour ajouter une énième démo IA, mais pour répondre à une question précise : à quoi devrait vraiment ressembler une architecture Data + IA qu'on pourrait recommander à une entreprise en 2026 ?
En creusant l'ancienne version du projet (une plateforme data pour un cas d'usage de livraison de repas : Snowflake, dbt, Airflow, plus une couche IA), j'ai trouvé le vrai problème. Le taux d'annulation était calculé indépendamment à trois endroits : deux dashboards et le prompt du module text-to-SQL. Trois définitions différentes du même chiffre, et rien ne garantissait qu'elles restent alignées dans le temps.
Pire : j'étais sur le point d'ajouter une quatrième version, celle qu'un LLM aurait pu générer tout seul avec un accès direct aux tables. Une IA n'invente pas de logique métier qui n'existe pas déjà quelque part, elle répète ce qu'on lui donne à lire, avec la confiance d'un système qui ne doute jamais de lui-même. Si sa version du taux d'annulation avait divergé des deux dashboards existants, elle aurait produit une réponse fausse avec la même assurance qu'une réponse juste.
Je me suis arrêté avant. J'ai repensé l'architecture autour d'un principe simple : une seule définition par métrique, une seule couche que tout le monde lit (dashboards, RAG, text-to-SQL), et personne ne touche aux données brutes. Pas même l'IA.
Le problème en détail
Concrètement, voici à quoi ressemblait la duplication en code. Le mart de revenu quotidien par ville calculait le taux d'annulation directement dans sa requête SQL :
-- Avant la couche sémantique : chaque mart réécrivait sa propre logique
select
order_date,
city,
count(*) as orders,
round(div0(count_if(order_status = 'Cancelled'), count(*)), 4) as cancel_rate
from fact_orders
group by 1, 2Le mart de performance restaurant faisait la même opération, mais avec sa propre variation d'écriture SQL, à un autre endroit du repo. Et le prompt text-to-SQL décrivait, dans une simple chaîne de caractères passée au LLM, sa propre explication de ce qu'est un "taux d'annulation", sans lien programmatique avec le SQL réel qui tourne dans dbt.
Le risque n'est pas hypothétique. Une expression SQL copiée-collée trois fois finit toujours par diverger : quelqu'un corrige un cas limite dans une copie et oublie les deux autres, quelqu'un change la définition métier ("est-ce qu'un remboursement compte comme une annulation ?") dans un seul endroit, ou pire, personne ne remarque que les trois définitions ne s'accordent déjà plus sur les commandes à statut ambigu. Ce genre de dérive est invisible tant que personne ne compare les trois chiffres côte à côte. Et une fois qu'une IA lit les données brutes pour répondre à une question business, elle devient un quatrième point de dérive, moins visible que les deux premiers puisqu'elle génère sa réponse à la volée plutôt que de la matérialiser dans un dashboard qu'on peut auditer.
L'architecture complète
La solution que j'ai mise en place repose sur un empilement medallion classique (Bronze, Silver, Gold), avec une couche supplémentaire au sommet : une couche sémantique, seule source de vérité pour toute consommation, humaine ou IA.
S3 landing (immuable) -> RAW (Bronze, COPY INTO + métadonnées)
-> STAGING (Silver, dbt) -> MARTS (Gold, dbt) -> SEMANTIC (dbt)
|-- BI / dashboards
`-- IA : enrichissement (écrivain, -> schéma AI) / RAG / text-to-SQL (lecteurs, SEMANTIC uniquement)
Chaque couche a un rôle strict. Bronze copie les données sources telles quelles, sans la moindre logique métier, même pas un TRIM(). Silver type et déduplique, une ligne par clé métier. Gold construit le schéma en étoile (fact_orders, dim_customer, etc.) et les marts métier. Aucune de ces couches ne recalcule une métrique déjà définie ailleurs : c'est la règle qui manquait dans la version originale du projet.
La vraie nouveauté est la couche sémantique, et elle tient en trois pièces, toutes en dbt natif, sans introduire de nouvel outil.
1. Un macro dbt par métrique, définie une seule fois :
{% macro cancellation_rate_expr(status_col='order_status', cancelled_value="'Cancelled'") -%}
ROUND(DIV0(COUNT_IF({{ status_col }} = {{ cancelled_value }}), COUNT(*)), 4)
{%- endmacro %}Chaque mart et chaque vue sémantique qui a besoin du taux d'annulation appelle ce macro plutôt que de réécrire l'expression SQL :
-- Grain: one row per (order_date, city). Every measure calls the shared
-- macro definitions in macros/metrics.sql.
select
order_date,
city,
count(*) as orders,
{{ delivered_orders_expr() }} as delivered_orders,
{{ cancellation_rate_expr() }} as cancel_rate,
{{ gross_merchandise_value_expr() }} as gross_merchandise_value,
{{ average_order_value_expr() }} as average_order_value
from {{ ref('fact_orders') }}
group by 1, 22. Des vues sémantiques fines au-dessus des marts Gold, qui ne recalculent rien : elles se contentent d'exposer ce que le mart a déjà produit.
-- Thin, documented pass-through of mart_daily_city_revenue. Not
-- re-deriving GMV/cancel_rate/AOV here, on purpose: the semantic layer's
-- job is to be the one place consumers are granted access to, not
-- another place metric logic lives.
select
order_date,
city,
orders,
delivered_orders,
cancel_rate,
gross_merchandise_value,
average_order_value
from {{ ref('mart_daily_city_revenue') }}3. Un dictionnaire de métriques (metrics.yml), qui documente chaque métrique : nom, description, grain, vue sémantique propriétaire, SQL. Il est lu directement par le code Python qui construit le prompt du LLM. Pas de copier-coller entre le YAML et le prompt : le même fichier sert aux deux.
J'ai sciemment écarté les produits dédiés de couche sémantique (dbt Semantic Layer / MetricFlow, Cube, LookML). Ces outils apportent un vrai bénéfice quand plusieurs outils BI ont besoin d'une interface de requête dynamique et partagée sur des dizaines de métriques. Ici, il y a une douzaine de métriques et un seul consommateur programmatique. Ajouter un service de query planning, une nouvelle cible de déploiement et un nouveau langage de modélisation pour ce volume, c'est de l'infrastructure dimensionnée pour un problème que je n'ai pas. Le jour où plusieurs outils BI auront besoin de slicing dimensionnel dynamique sur ces métriques, le dictionnaire metrics.yml est exactement l'artefact dont partirait cette migration.
La couche IA et ses garde-fous
Trois capacités IA lisent cette couche sémantique, chacune sous un rôle Snowflake dédié qui ne dépasse jamais son périmètre.
L'enrichissement batch classe les avis clients (sentiment, thème) de façon idempotente et rejouable. Avant qu'un commentaire n'atteigne le fournisseur LLM, il passe par un nettoyage PII volontairement simple :
_EMAIL_RE = re.compile(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}")
_CREDIT_CARD_RE = re.compile(r"\b(?:\d[ -]?){13,16}\b")
_PHONE_RE = re.compile(r"\b(?:\+?\d{1,3}[ -]?)?(?:\(\d{2,4}\)[ -]?)?\d{3,4}[ -]?\d{3,4}[ -]?\d{0,4}\b")Ce n'est pas une solution de conformité PII générale : ça ne détecte ni les noms ni les adresses, ce qui demanderait un modèle NER. Mais à l'échelle d'un commentaire client en texte libre, une poignée de patterns bien testés (email, téléphone, carte bancaire) attrape les fuites les plus évidentes, sans ajouter de latence ni de service externe. Chaque tentative d'enrichissement, réussie ou échouée, est journalisée avec le nom du modèle, sa version et la version du prompt utilisé, pour qu'un échec reste visible et rejouable plutôt que silencieusement perdu.
Le text-to-SQL est la capacité la plus exposée, donc celle qui a le plus de garde-fous, en profondeur plutôt qu'en une seule barrière. La première couche est une validation statique du SQL généré par le LLM, avec un vrai parseur (sqlglot), pas une liste de mots interdits :
DISALLOWED_NODE_TYPES = (
exp.Insert, exp.Update, exp.Delete, exp.Drop, exp.Alter, exp.Create,
exp.Merge, exp.Command, exp.Grant, exp.Copy,
)
def validate_and_prepare(candidate_sql, allowed_tables, default_schema, row_limit):
statements = sqlglot.parse(candidate_sql, read="snowflake")
...
disallowed = list(root.find_all(*DISALLOWED_NODE_TYPES))
if disallowed:
kinds = sorted({type(n).__name__ for n in disallowed})
raise GuardrailViolation(f"Disallowed operation(s) found: {', '.join(kinds)}.")
_check_table_allowlist(root, allowed_tables, default_schema)
_enforce_row_limit(inner, row_limit)Une liste noire de mots-clés type "drop" not in sql.lower() se fait piéger par une colonne nommée dropoff_time ou par une chaîne de caractères entre guillemets. Parser réellement l'arbre syntaxique évite ce genre de faux négatif.
Mais la vraie garantie n'est pas là. Elle est dans le rôle Snowflake sous lequel la requête s'exécute réellement :
CREATE ROLE IF NOT EXISTS AI_READONLY_ROLE
COMMENT = 'RAG + text-to-SQL. SELECT on SEMANTIC only.';
GRANT USAGE ON SCHEMA SEMANTIC TO ROLE AI_READONLY_ROLE;
GRANT SELECT ON ALL VIEWS IN SCHEMA SEMANTIC TO ROLE AI_READONLY_ROLE;
GRANT SELECT ON FUTURE VIEWS IN SCHEMA SEMANTIC TO ROLE AI_READONLY_ROLE;
ALTER ROLE AI_READONLY_ROLE SET STATEMENT_TIMEOUT_IN_SECONDS = 30;Ce rôle n'a aucun droit d'écriture nulle part, et aucun accès en dehors du schéma SEMANTIC. C'est la défense en profondeur dont je parlais : si la validation applicative a un bug, si une injection de prompt trouve une faille dans le parseur, la pire conséquence possible est une erreur confuse renvoyée à l'utilisateur, jamais une lecture d'une table hors périmètre ni une écriture. La garantie qui compte vraiment vient de la base de données elle-même, pas du code Python qui tourne devant.
Ce choix de conception a une autre conséquence, plus subtile mais tout aussi importante : parce que l'IA lit exactement les mêmes vues sémantiques et les mêmes définitions de métriques qu'un dashboard, une réponse de l'IA et un chiffre affiché sur un dashboard ne peuvent jamais diverger simplement parce que l'IA aurait un accès différent ou plus permissif aux données. C'est exactement le problème de départ qui disparaît.
Qualité des données et observabilité
La sévérité d'un test dbt n'est jamais implicite dans ce projet, elle est déclarée explicitement, ligne par ligne :
- name: sales_amount
tests:
- dbt_utils.expression_is_true:
expression: ">= 0"
config:
severity: warnUn test bloquant (severity: error, le défaut) arrête le DAG Airflow avant que l'enrichissement IA ou la publication ne se lance : unicité et non-nullité des clés primaires, intégrité référentielle, valeurs acceptées. Un test en avertissement (severity: warn) est journalisé mais ne bloque rien, par exemple une fraîcheur légèrement dépassée ou une règle métier souple. Un test singulier vérifie même que la couche sémantique ne perd silencieusement aucune ligne par rapport au mart Gold qu'elle enveloppe :
with gold as (
select count(*) as n from {{ ref('mart_daily_city_revenue') }}
),
semantic as (
select count(*) as n from {{ ref('sem_revenue_daily') }}
)
select gold.n as gold_row_count, semantic.n as semantic_row_count
from gold, semantic
where gold.n != semantic.nTrois tables de contrôle permettent de répondre à "qu'est-ce qui a tourné, avec quel résultat" sans avoir à fouiller des logs : INGESTION_RUNS trace chaque tentative d'ingestion par run et par fichier source, AI.ENRICHMENT_LOG trace chaque tentative d'enrichissement IA (avec le nombre de PII redigées, pour repérer un pic anormal sans relire chaque commentaire brut), et PIPELINE_RUNS résume chaque run complet du DAG Airflow. Un seul run_id traverse ces trois tables, donc n'importe quelle ligne de fact_orders se retrace jusqu'au fichier source exact et au run Airflow qui l'a chargée.
Ce que j'ai volontairement laissé de côté
Il est tentant, sur un projet de référence, d'ajouter des outils "impressionnants" pour donner un genre plus "enterprise". J'ai délibérément écarté Kafka, Spark, Kubernetes, Databricks et une base vectorielle dédiée, pas par méconnaissance, mais parce qu'aucun ne résout un problème que cette plateforme a réellement, à son échelle réelle.
Kafka résout un problème de livraison d'événements en dessous de la minute. Rien dans les besoins métier (reporting de revenu, enrichissement d'avis, SLA de livraison) n'a besoin d'une fraîcheur aussi agressive : les sources s'extraient en batch quotidien. Spark résout un problème de calcul distribué sur des volumes trop gros pour un entrepôt classique, alors que chaque transformation ici s'exprime en SQL que Snowflake exécute nativement. Kubernetes orchestre des services indépendamment scalables, alors qu'ici une poignée de services (Airflow, Postgres, Streamlit) tournent confortablement sur un Docker Compose à hôte unique. Et pour la recherche vectorielle du RAG, une matrice d'embeddings mise en cache par hash de contenu répond en quelques millisecondes à l'échelle de quelques centaines de milliers d'avis clients, sans infrastructure supplémentaire.
Chacun de ces outils est légitime, juste pour un problème d'une autre échelle. Les adopter ici aurait ajouté de la complexité opérationnelle réelle (clusters à gérer, registre de schémas, réconciliation entre systèmes) pour un bénéfice qui ne se mesure pas. C'est exactement le piège que je voulais éviter : un projet impressionnant sur le papier mais injustifié dans les faits.
Ce que je changerais à plus grande échelle
Rien de tout ça n'est gravé dans le marbre, et le repo documente explicitement les déclencheurs qui justifieraient de changer chaque choix.
- Un besoin réel de fraîcheur en dessous de la minute (par exemple un suivi de commande en temps réel) justifierait d'ajouter une ingestion streaming en complément du chemin batch, pas à sa place.
- Si la recherche vectorielle devenait trop lente à volume,
ParquetVectorStorepeut être remplacé par pgvector ou une base vectorielle managée, sans réécrire le pipeline, puisqueVectorStoreest défini comme une interface (Protocol). - Si plusieurs outils BI avaient besoin d'un slicing dimensionnel dynamique sur les métriques, migrer les définitions de
metrics.ymlvers un vrai produit de couche sémantique deviendrait l'étape suivante naturelle. - Si l'équipe dépassait la capacité d'un Airflow mono-hôte, basculer vers un Airflow managé (MWAA, Composer, Astronomer) serait le prochain palier.
Aucun de ces changements n'est une réécriture depuis zéro. Ce sont des évolutions additives ou des remplacements à interface identique, parce que les points d'extension (Source, VectorStore, le dictionnaire metrics.yml) ont été pensés pour ça dès le départ.
Conclusion
La différence entre une IA qu'on montre en démo et une IA qu'on ose brancher sur des données de production tient rarement au choix du modèle. Elle tient à ce qu'il y a en dessous : est-ce que la donnée que l'IA lit a une définition unique, testée, et partagée avec tout le reste du système, ou est-ce que l'IA vient ajouter sa propre version de la vérité à une pile qui en avait déjà trop.
Le code complet, les sept ADR qui documentent chaque choix d'architecture, et les tests qui les valident sont sur GitHub : github.com/Tianarandr/end-to-end-de-pipeline.