Parcourir les aide-mémoire · Ingénierie IA pour les données
Patrons de prompts pour l’ingénierie des données
Des patrons de prompts réutilisables pour l’ingénierie des données : génération SQL, interprétation de schéma, mapping de colonnes, règles de qualité et analyse d’incident, avec sortie structurée, hypothèses explicites et validation.
Sur cette page
- Problème
- Réponse rapide
- Patron de base
- Code / commandes
- 1. Génération de SQL
- 2. Explication de SQL
- 3. Interprétation de schéma
- 4. Mapping de colonnes
- 5. Génération de règles de qualité des données
- 6. Résumé de journaux
- 7. Analyse d’incident
- 8. Explication de notebook et de code
- 9. Documentation de pipeline
- 10. Enrichissement des métadonnées
- Techniques réutilisables
- Mauvais prompt ou meilleur prompt
- Patron de sortie structurée
- Patron « demander les hypothèses »
- Patron « renvoyer l’incertitude »
- Étape de validation
- Points à vérifier
- Erreurs fréquentes
- 1. Envoyer des secrets ou des données clients brutes
- 2. Envoyer tout le schéma
- 3. Aucun format de sortie
- 4. Exécuter directement le SQL généré
- 5. Mélanger instructions et données
- 6. Exiger une certitude
- Notes de production
- Liste de contrôle
- Étape suivante
- Pour aller plus loin
Problème
Les LLM peuvent aider dans le travail de données quotidien :
- écrire et expliquer du SQL
- interpréter des schémas inconnus
- faire correspondre des colonnes source à un modèle cible
- rédiger des règles de qualité des données
- résumer des journaux et des incidents
- documenter des notebooks et des pipelines
- enrichir des métadonnées
Un prompt vague donne une réponse plausible mais difficile à vérifier. Les tâches de données exigent des prompts qui précisent le contexte, les contraintes et la sortie attendue, ainsi qu’une étape de validation qui ne fait pas confiance au modèle.
Réponse rapide
Utilisez la même structure pour chaque prompt de données :
Objectif : quoi produire, pour qui
Contexte : uniquement le schéma, l'échantillon, les journaux ou les règles nécessaires
Contraintes : dialecte, conventions de nommage, limites, ce qu'il ne faut pas faire
Entrée : la donnée ou la question, clairement délimitée
Sortie : format exact (schéma JSON, SQL seul, tableau)
Validation : ce qui rend la réponse acceptable ; lister les hypothèses ; répondre « inconnu » en cas de doute
Validez ensuite la sortie avec du code, la base de données ou un relecteur avant de l’utiliser.
Ne mettez jamais de secrets, d’identifiants ni de données clients sensibles brutes dans un prompt.
Patron de base
## Objectif
Écris une requête T-SQL qui répond à la question ci-dessous.
## Contexte
Tables (seules celles-ci existent) :
orders(order_id int pk, customer_id int, order_date date, status varchar, amount decimal(12,2))
customers(customer_id int pk, country char(2), segment varchar)
## Contraintes
- SQL Server 2022, SELECT en lecture seule
- utilise uniquement les tables et colonnes listées
- renvoie au maximum 1000 lignes
## Entrée
<question>Chiffre d'affaires par pays des commandes expédiées en septembre 2026.</question>
## Sortie
Renvoie du JSON : {"sql": string, "assumptions": [string], "confidence": "high" | "medium" | "low"}
## Validation
S'il manque une colonne nécessaire, renvoie "sql": null et explique-le dans "assumptions".
Délimitez les entrées (<question>, <logs>, <schema>) pour que les données ne soient pas confondues avec les instructions.
Code / commandes
1. Génération de SQL
Mauvais :
Écris une requête pour le chiffre d'affaires par pays.
Mieux : utilisez le patron de base ci-dessus. Il fixe le dialecte, les tables exactes, les filtres à interpréter et un format à valider.
Validez avant d’exécuter : compilez sans exécuter, avec un compte en lecture seule.
SET NOEXEC ON; -- SQL Server : compile et vérifie les noms, sans exécuter
SELECT TOP (1000) c.country, SUM(o.amount) AS revenue
FROM dbo.orders AS o
JOIN dbo.customers AS c ON c.customer_id = o.customer_id
WHERE o.status = 'shipped'
AND o.order_date >= '2026-09-01' AND o.order_date < '2026-10-01'
GROUP BY c.country;
SET NOEXEC OFF;
Les autres moteurs ont des équivalents (par exemple EXPLAIN). Comparez ensuite le résultat à un chiffre connu avant de faire confiance à la requête.
2. Explication de SQL
Explique ce que fait cette requête à un analyste de données.
<sql>
...requête...
</sql>
Sortie (Markdown) :
1. Objectif en une phrase.
2. Logique étape par étape (jointures, filtres, regroupements).
3. Granularité du résultat : ce que représente une ligne.
4. Risques : doublons possibles dus aux jointures, gestion des NULL, bornes de dates.
Ne réécris pas la requête.
Demander la granularité et les risques transforme une paraphrase en revue.
3. Interprétation de schéma
Décris la signification métier probable de chaque table et les relations entre elles.
<schema>
...DDL ou liste des colonnes avec types, clés et quelques valeurs d'exemple masquées...
</schema>
Sortie JSON :
{"tables": [{"name": string, "meaning": string, "grain": string,
"keys": [string], "evidence": string, "confidence": "high"|"medium"|"low"}]}
Tout ce qui est déduit uniquement des noms doit avoir "confidence": "low".
4. Mapping de colonnes
Fais correspondre les colonnes source au modèle cible.
<source_columns>cust_no, e_mail, ctry, created_ts, mkt_optin</source_columns>
<target_columns>customer_id, email, country_code, signup_date, marketing_consent</target_columns>
Règles :
- chaque colonne source correspond à au plus une colonne cible
- si aucune cible ne convient, utilise null
- n'invente pas de colonnes cibles
Sortie JSON :
{"mappings": [{"source": string, "target": string | null,
"transformation": string | null, "confidence": number}]}
Validez le mapping avec du code :
import json
ALLOWED_TARGETS = {"customer_id", "email", "country_code", "signup_date", "marketing_consent"}
def validate_mapping(raw: str, source_columns: set[str]) -> list[str]:
"""Renvoie les problèmes trouvés ; une liste vide signifie que le mapping peut passer en revue humaine."""
try:
mapping = json.loads(raw)
except json.JSONDecodeError as exc:
return [f"JSON invalide : {exc}"]
problems = []
for item in mapping.get("mappings", []):
source, target, confidence = item.get("source"), item.get("target"), item.get("confidence")
if source not in source_columns:
problems.append(f"colonne source inconnue : {source}")
if target is not None and target not in ALLOWED_TARGETS:
problems.append(f"colonne cible inconnue : {target}")
if not isinstance(confidence, (int, float)) or not 0 <= confidence <= 1:
problems.append(f"confiance invalide pour {source}")
return problems
5. Génération de règles de qualité des données
Propose des contrôles de qualité des données pour cette table.
<table_profile>
column, type, null_pct, distinct_count, min, max, sample_values (masquées)
...
</table_profile>
Sortie JSON :
{"rules": [{"column": string, "check": "not_null"|"unique"|"range"|"allowed_values"|"pattern",
"parameters": object, "reason": string, "severity": "error"|"warning"}]}
Fonde chaque règle sur le profil. Ne propose pas de seuil sans preuve ; indique « à confirmer ».
Transformez les règles acceptées en code (SQL, PySpark ou votre framework de qualité) et relisez-les comme n’importe quel code.
6. Résumé de journaux
Résume ces journaux de pipeline pour un ingénieur d'astreinte.
<logs>
...200 dernières lignes pertinentes, secrets et jetons retirés...
</logs>
Sortie :
- Première erreur (horodatage, composant, message)
- Enchaînement probable des événements (5 puces maximum)
- Ce que ces journaux NE montrent PAS
Cite les lignes de journal à l'identique ; ne reformule pas les messages d'erreur.
Filtrez d’abord les journaux avec du code (niveau, fenêtre de temps, ID d’exécution). N’envoyez pas des fichiers de journaux entiers.
7. Analyse d’incident
Aide à analyser cet incident. Tu assistes, tu ne décides pas.
<timeline>...</timeline>
<metrics>...</metrics>
<recent_changes>...</recent_changes>
Sortie JSON :
{"hypotheses": [{"cause": string, "supporting_evidence": [string],
"contradicting_evidence": [string], "next_check": string}],
"unknowns": [string]}
Classe les hypothèses selon les preuves. N'affirme pas une cause racine comme un fait.
8. Explication de notebook et de code
Explique cette cellule de notebook à un ingénieur de données qui découvre le projet.
<code language="python">
...
</code>
Sortie :
1. Ce qu'elle lit et écrit (tables, fichiers, chemins).
2. Les transformations dans l'ordre.
3. Les effets de bord (écrasements, suppressions, merges).
4. Les risques de performance (collect(), boucles sur les lignes, shuffles importants).
9. Documentation de pipeline
Rédige une documentation de ce pipeline à partir de sa définition.
<pipeline_definition>...JSON/YAML, secrets retirés...</pipeline_definition>
Sortie Markdown avec les sections : Objectif, Planification, Sources, Cibles, Étapes,
Gestion des échecs, Responsables (« à définir » s'ils ne figurent pas dans l'entrée).
Décris uniquement ce qui figure dans la définition.
10. Enrichissement des métadonnées
Propose des descriptions métier et des étiquettes pour ces colonnes.
<columns>nom, type, table, valeurs d'exemple (masquées)</columns>
Sortie JSON :
{"columns": [{"name": string, "description": string,
"tags": [string], "pii_suspected": boolean, "confidence": "high"|"medium"|"low"}]}
Utilise uniquement ces étiquettes : finance, customer, product, operational, reference.
Stockez les suggestions comme brouillons à faire approuver par un responsable des données (data steward).
Techniques réutilisables
Mauvais prompt ou meilleur prompt
| Mauvais | Meilleur |
|---|---|
| « Corrige ce SQL » | « Ce T-SQL renvoie des doublons par commande. Explique pourquoi et renvoie une requête corrigée. Garde les mêmes colonnes en sortie. » |
| « Résume les journaux » | « Liste la première erreur, le composant en échec et la dernière étape réussie. Cite les lignes à l’identique. » |
| « Fais correspondre ces colonnes » | « Associe chaque colonne source à une colonne cible ou à null. Renvoie du JSON conforme à ce schéma. » |
Patron de sortie structurée
- Définissez le schéma dans le prompt, ou utilisez la fonction de sortie structurée du fournisseur.
- Utilisez des énumérations pour les catégories.
- Analysez et validez avec du code ; relancez ou escaladez en cas d’échec.
Patron « demander les hypothèses »
Avant la réponse, liste les hypothèses faites sur les données
(granularité, fuseau horaire, signification des statuts, gestion des NULL).
C’est dans les hypothèses que les réponses sur les données se trompent ; les rendre explicites accélère la revue.
Patron « renvoyer l’incertitude »
Si l'entrée ne contient pas assez d'informations, renvoie "unknown"
et liste ce qui manque. Ne devine pas.
Donnez au modèle un moyen légitime de dire qu’il ne sait pas.
Étape de validation
| Sortie | Valider avec |
|---|---|
| SQL | Compilation sans exécution, compte en lecture seule, limite de lignes, comparaison à un total connu |
| JSON | Analyse + validation de schéma + valeurs autorisées |
| Mappings / règles | Contrôles en code + approbation humaine |
| Résumés | Les lignes citées existent dans la source |
| Code | Tests, linting, revue |
Points à vérifier
- Des réponses qui utilisent des tables ou colonnes absentes du contexte.
- Des hypothèses manquantes sur la granularité, les fuseaux horaires ou les NULL.
- Des réponses assurées à des questions auxquelles l’entrée ne permet pas de répondre.
- Des sorties conformes au schéma mais qui échouent aux contrôles métier.
- Des valeurs sensibles qui apparaissent dans les prompts ou les journaux.
Erreurs fréquentes
1. Envoyer des secrets ou des données clients brutes
Chaînes de connexion, clés, jetons et données personnelles n’ont rien à faire dans un prompt. Masquez, échantillonnez, synthétisez ou agrégez d’abord.
2. Envoyer tout le schéma
Un contexte volumineux et non pertinent coûte des tokens et favorise les mauvaises jointures. Envoyez les tables utiles.
3. Aucun format de sortie
Le texte libre est difficile à valider et à utiliser dans un pipeline.
4. Exécuter directement le SQL généré
Compilez-le, exécutez-le en lecture seule avec des limites et vérifiez le résultat.
5. Mélanger instructions et données
Des données collées sans délimiteurs peuvent être prises pour des instructions, y compris des instructions cachées dans les données elles-mêmes.
6. Exiger une certitude
« Quelle est la cause racine ? » invite à une supposition assurée. Demandez des hypothèses étayées par des preuves.
Notes de production
- Gardez les prompts sous contrôle de version sous forme de modèles ; journalisez la version du modèle de prompt avec chaque appel.
- Construisez les prompts en code à partir de modèles, pas en concaténant la saisie utilisateur dans les instructions.
- Traitez documents récupérés, journaux et saisies utilisateur comme des données non fiables.
- Utilisez un rôle de base de données en lecture seule pour toute requête générée.
- Masquez ou retirez données personnelles et secrets avant de construire les prompts ; vérifiez ce que capture votre journalisation.
- Gardez un petit jeu d’évaluation par prompt et relancez-le après chaque modification ou changement de modèle.
Liste de contrôle
- Objectif, contexte, contraintes, entrée, sortie et validation sont explicites.
- Seuls le schéma, l’échantillon ou les journaux nécessaires sont envoyés.
- Les entrées sont délimitées.
- La sortie a un format défini.
- Le modèle doit lister ses hypothèses et peut répondre « inconnu ».
- La sortie est validée par du code, la base de données ou un relecteur.
- Aucun secret ni donnée sensible brute dans les prompts.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.