Explorar guías rápidas · Ingeniería de IA para datos

Tecnología: Ingeniería de IA para datosCategoría: Diseño de promptsNivel: IntermedioActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Patrón base
  4. Código / comandos
  5. 1. Generación de SQL
  6. 2. Explicación de SQL
  7. 3. Interpretación de esquemas
  8. 4. Mapeo de columnas
  9. 5. Generación de reglas de calidad de datos
  10. 6. Resumen de logs
  11. 7. Análisis de incidentes
  12. 8. Explicación de notebooks y código
  13. 9. Documentación de pipelines
  14. 10. Enriquecimiento de metadatos
  15. Técnicas reutilizables
  16. Prompt malo frente a prompt mejor
  17. Patrón de salida estructurada
  18. Patrón «pedir los supuestos»
  19. Patrón «devolver la incertidumbre»
  20. Paso de validación
  21. Qué revisar
  22. Errores comunes
  23. 1. Enviar secretos o datos de clientes sin procesar
  24. 2. Enviar todo el esquema
  25. 3. Sin formato de salida
  26. 4. Ejecutar directamente el SQL generado
  27. 5. Mezclar instrucciones y datos
  28. 6. Pedir certeza
  29. Notas de producción
  30. Lista de comprobación
  31. Siguiente paso
  32. 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.

Siguiente paso

  • Los prompts son demasiado largos o caros → Optimización de tokens en LLM.
  • No tienes claro qué contexto incluir → Ingeniería de contexto para LLM.
  • Los resultados son flojos incluso con un buen prompt → Elegir el modelo de IA adecuado.

← Todas las guías rápidas