Explorar guías rápidas · Ingeniería de IA para datos
Patrones de prompts para ingeniería de datos
Patrones de prompts reutilizables para ingeniería de datos: generación de SQL, interpretación de esquemas, mapeo de columnas, reglas de calidad y análisis de incidentes, con salida estructurada, supuestos explícitos y validación.
En esta página
- Problema
- Respuesta rápida
- Patrón base
- Código / comandos
- 1. Generación de SQL
- 2. Explicación de SQL
- 3. Interpretación de esquemas
- 4. Mapeo de columnas
- 5. Generación de reglas de calidad de datos
- 6. Resumen de logs
- 7. Análisis de incidentes
- 8. Explicación de notebooks y código
- 9. Documentación de pipelines
- 10. Enriquecimiento de metadatos
- Técnicas reutilizables
- Prompt malo frente a prompt mejor
- Patrón de salida estructurada
- Patrón «pedir los supuestos»
- Patrón «devolver la incertidumbre»
- Paso de validación
- Qué revisar
- Errores comunes
- 1. Enviar secretos o datos de clientes sin procesar
- 2. Enviar todo el esquema
- 3. Sin formato de salida
- 4. Ejecutar directamente el SQL generado
- 5. Mezclar instrucciones y datos
- 6. Pedir certeza
- Notas de producción
- Lista de comprobación
- Siguiente paso
- Para profundizar
Problema
Los LLM pueden ayudar en el trabajo diario con datos:
- escribir y explicar SQL
- interpretar esquemas desconocidos
- mapear columnas de origen a un modelo de destino
- redactar reglas de calidad de datos
- resumir logs e incidentes
- documentar notebooks y pipelines
- enriquecer metadatos
Un prompt vago produce una respuesta plausible pero difícil de comprobar. Las tareas de datos necesitan prompts que indiquen el contexto, las restricciones y la salida esperada, y un paso de validación que no confíe en el modelo.
Respuesta rápida
Usa la misma estructura en cada prompt de datos:
Objetivo: qué producir y para quién
Contexto: solo el esquema, la muestra, los logs o las reglas necesarios
Restricciones: dialecto, nomenclatura, límites, qué no hacer
Entrada: el dato o la pregunta, claramente delimitados
Salida: formato exacto (esquema JSON, solo SQL, tabla)
Validación: qué hace aceptable la respuesta; listar supuestos; responder «desconocido» si hay dudas
Después valida la salida con código, con la base de datos o con un revisor antes de usarla.
Nunca pongas secretos, credenciales ni datos sensibles de clientes sin procesar en un prompt.
Patrón base
## Objetivo
Escribe una consulta T-SQL que responda a la pregunta de abajo.
## Contexto
Tablas (solo existen estas):
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)
## Restricciones
- SQL Server 2022, SELECT de solo lectura
- usa solo las tablas y columnas indicadas
- devuelve como máximo 1000 filas
## Entrada
<question>Ingresos por país de los pedidos enviados en septiembre de 2026.</question>
## Salida
Devuelve JSON: {"sql": string, "assumptions": [string], "confidence": "high" | "medium" | "low"}
## Validación
Si falta una columna necesaria, devuelve "sql": null y explícalo en "assumptions".
Delimita las entradas (<question>, <logs>, <schema>) para que los datos no se confundan con instrucciones.
Código / comandos
1. Generación de SQL
Malo:
Escribe una consulta de ingresos por país.
Mejor: usa el patrón base de arriba. Fija el dialecto, las tablas exactas, los filtros que hay que interpretar y un formato que se puede validar.
Valida antes de ejecutar: compila sin ejecutar, con un usuario de solo lectura.
SET NOEXEC ON; -- SQL Server: compila y comprueba los nombres, sin ejecutar
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;
Otros motores tienen equivalentes (por ejemplo, EXPLAIN). Después compara el resultado con una cifra conocida antes de confiar en la consulta.
2. Explicación de SQL
Explica qué hace esta consulta a un analista de datos.
<sql>
...consulta...
</sql>
Salida (Markdown):
1. Propósito en una frase.
2. Lógica paso a paso (joins, filtros, agrupaciones).
3. Granularidad del resultado: qué representa una fila.
4. Riesgos: posibles duplicados por los joins, manejo de NULL, límites de fechas.
No reescribas la consulta.
Pedir la granularidad y los riesgos convierte una paráfrasis en una revisión.
3. Interpretación de esquemas
Describe el significado de negocio probable de cada tabla y las relaciones entre ellas.
<schema>
...DDL o lista de columnas con tipos, claves y algunos valores de ejemplo enmascarados...
</schema>
Salida JSON:
{"tables": [{"name": string, "meaning": string, "grain": string,
"keys": [string], "evidence": string, "confidence": "high"|"medium"|"low"}]}
Marca con "confidence": "low" todo lo que se deduzca solo de los nombres.
4. Mapeo de columnas
Mapea las columnas de origen al modelo de destino.
<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>
Reglas:
- cada columna de origen corresponde como máximo a una columna de destino
- si ningún destino encaja, usa null
- no inventes columnas de destino
Salida JSON:
{"mappings": [{"source": string, "target": string | null,
"transformation": string | null, "confidence": number}]}
Valida el mapeo con código:
import json
ALLOWED_TARGETS = {"customer_id", "email", "country_code", "signup_date", "marketing_consent"}
def validate_mapping(raw: str, source_columns: set[str]) -> list[str]:
"""Devuelve los problemas encontrados; una lista vacía significa que el mapeo puede pasar a revisión humana."""
try:
mapping = json.loads(raw)
except json.JSONDecodeError as exc:
return [f"JSON no válido: {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"columna de origen desconocida: {source}")
if target is not None and target not in ALLOWED_TARGETS:
problems.append(f"columna de destino desconocida: {target}")
if not isinstance(confidence, (int, float)) or not 0 <= confidence <= 1:
problems.append(f"confianza no válida para {source}")
return problems
5. Generación de reglas de calidad de datos
Propón controles de calidad de datos para esta tabla.
<table_profile>
column, type, null_pct, distinct_count, min, max, sample_values (enmascarados)
...
</table_profile>
Salida JSON:
{"rules": [{"column": string, "check": "not_null"|"unique"|"range"|"allowed_values"|"pattern",
"parameters": object, "reason": string, "severity": "error"|"warning"}]}
Basa cada regla en el perfil. No propongas umbrales sin evidencia; márcalos «por confirmar».
Convierte las reglas aceptadas en código (SQL, PySpark o tu framework de calidad) y revísalas como cualquier otro código.
6. Resumen de logs
Resume estos logs de pipeline para un ingeniero de guardia.
<logs>
...últimas 200 líneas relevantes, sin secretos ni tokens de acceso...
</logs>
Salida:
- Primer error (marca de tiempo, componente, mensaje)
- Secuencia probable de eventos (máximo 5 viñetas)
- Lo que estos logs NO muestran
Cita las líneas de log literalmente; no parafrasees los mensajes de error.
Filtra primero los logs con código (nivel, ventana de tiempo, ID de ejecución). No envíes archivos de log completos.
7. Análisis de incidentes
Ayuda a analizar este incidente. Asistes, no decides.
<timeline>...</timeline>
<metrics>...</metrics>
<recent_changes>...</recent_changes>
Salida JSON:
{"hypotheses": [{"cause": string, "supporting_evidence": [string],
"contradicting_evidence": [string], "next_check": string}],
"unknowns": [string]}
Ordena las hipótesis según la evidencia. No presentes una causa raíz como un hecho.
8. Explicación de notebooks y código
Explica esta celda de notebook a un ingeniero de datos nuevo en el proyecto.
<code language="python">
...
</code>
Salida:
1. Qué lee y qué escribe (tablas, archivos, rutas).
2. Las transformaciones en orden.
3. Efectos secundarios (sobrescrituras, borrados, merges).
4. Riesgos de rendimiento (collect(), bucles sobre filas, shuffles grandes).
9. Documentación de pipelines
Redacta la documentación de este pipeline a partir de su definición.
<pipeline_definition>...JSON/YAML, sin secretos...</pipeline_definition>
Salida en Markdown con las secciones: Propósito, Programación, Orígenes, Destinos, Pasos,
Gestión de fallos, Responsables («por definir» si no aparecen en la entrada).
Describe solo lo que figura en la definición.
10. Enriquecimiento de metadatos
Sugiere descripciones de negocio y etiquetas para estas columnas.
<columns>nombre, tipo, tabla, valores de ejemplo (enmascarados)</columns>
Salida JSON:
{"columns": [{"name": string, "description": string,
"tags": [string], "pii_suspected": boolean, "confidence": "high"|"medium"|"low"}]}
Usa solo estas etiquetas: finance, customer, product, operational, reference.
Guarda las sugerencias como borradores para que las apruebe un responsable de datos (data steward).
Técnicas reutilizables
Prompt malo frente a prompt mejor
| Malo | Mejor |
|---|---|
| «Arregla este SQL» | «Este T-SQL devuelve duplicados por pedido. Explica por qué y devuelve una consulta corregida. Mantén las mismas columnas de salida.» |
| «Resume los logs» | «Indica el primer error, el componente que falla y el último paso correcto. Cita las líneas literalmente.» |
| «Mapea estas columnas» | «Mapea cada columna de origen a una columna de destino o a null. Devuelve JSON que cumpla este esquema.» |
Patrón de salida estructurada
- Define el esquema en el prompt, o usa la función de salida estructurada del proveedor.
- Usa enumeraciones para las categorías.
- Parsea y valida con código; reintenta o escala si falla.
Patrón «pedir los supuestos»
Antes de la respuesta, enumera los supuestos que hiciste sobre los datos
(granularidad, zona horaria, significado de los estados, manejo de NULL).
Los supuestos son donde fallan las respuestas sobre datos; hacerlos explícitos agiliza la revisión.
Patrón «devolver la incertidumbre»
Si la entrada no contiene información suficiente, devuelve "unknown"
y enumera lo que falta. No adivines.
Dale al modelo una forma legítima de decir que no lo sabe.
Paso de validación
| Salida | Validar con |
|---|---|
| SQL | Compilar sin ejecutar, usuario de solo lectura, límite de filas, comparar con un total conocido |
| JSON | Parseo + validación de esquema + valores permitidos |
| Mapeos / reglas | Comprobaciones en código + aprobación humana |
| Resúmenes | Las líneas citadas existen en la fuente |
| Código | Tests, linting, revisión |
Qué revisar
- Respuestas que usan tablas o columnas que no están en el contexto.
- Supuestos ausentes sobre granularidad, zonas horarias o NULL.
- Respuestas seguras a preguntas que la entrada no permite responder.
- Salidas que cumplen el esquema pero fallan las comprobaciones de negocio.
- Valores sensibles que aparecen en prompts o logs.
Errores comunes
1. Enviar secretos o datos de clientes sin procesar
Cadenas de conexión, claves, tokens de acceso y datos personales no deben ir en un prompt. Enmascara, muestrea, sintetiza o agrega primero.
2. Enviar todo el esquema
Un contexto grande e irrelevante cuesta tokens y favorece joins incorrectos. Envía las tablas relevantes.
3. Sin formato de salida
El texto libre es difícil de validar y de usar en un pipeline.
4. Ejecutar directamente el SQL generado
Compílalo, ejecútalo en solo lectura con límites y comprueba el resultado.
5. Mezclar instrucciones y datos
Los datos pegados sin delimitadores pueden interpretarse como instrucciones, incluidas instrucciones ocultas en los propios datos.
6. Pedir certeza
«¿Cuál es la causa raíz?» invita a una suposición segura. Pide hipótesis con evidencia.
Notas de producción
- Guarda los prompts en control de versiones como plantillas; registra la versión de la plantilla en cada llamada.
- Construye los prompts con código a partir de plantillas, no concatenando la entrada del usuario dentro de las instrucciones.
- Trata los documentos recuperados, los logs y la entrada del usuario como datos no confiables.
- Usa un rol de base de datos de solo lectura para cualquier consulta generada.
- Enmascara o elimina datos personales y secretos antes de construir los prompts; revisa qué captura tu registro.
- Mantén un pequeño conjunto de evaluación por prompt y vuelve a ejecutarlo tras cada cambio de prompt o de modelo.
Lista de comprobación
- Objetivo, contexto, restricciones, entrada, salida y validación son explícitos.
- Solo se envían el esquema, la muestra o los logs necesarios.
- Las entradas están delimitadas.
- La salida tiene un formato definido.
- Se pide al modelo que liste sus supuestos y se le permite responder «desconocido».
- La salida se valida con código, la base de datos o un revisor.
- Ningún secreto ni dato sensible sin procesar en los prompts.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.