Ingeniería de Prompts
La ingeniería de prompts da forma al comportamiento de los LLM a través de instrucciones, ejemplos y estructura. Los buenos prompts reducen las alucinaciones, imponen el formato de salida y mejoran la precisión de las tareas sin reentrenar el modelo.
Receta
Tarjeta de referencia rápida - lista para copiar y pegar.
SYSTEM = """Eres un revisor de código Python.
- Marca errores, problemas de seguridad y problemas de estilo.
- Responde en puntos.
- Si el código está bien, di "LGTM"."""
messages = [
{"role": "system", "content": SYSTEM},
{"role": "user", "content": f"Revisa este código:\n```python\n{code}\n```"},
]Cuándo usar esto:
- Definir un comportamiento consistente en las características de la aplicación.
- Enseñar el formato de salida con ejemplos few-shot.
- Mejorar el razonamiento con prompts de cadena de pensamiento.
- Reducir las alucinaciones con instrucciones de anclaje (grounding).
Ejemplo de Trabajo
"""prompt_engineering.py - prompts de sistema, few-shot, cadena de pensamiento y estructurados."""
from __future__ import annotations
from openai import OpenAI
client = OpenAI()
# Cadena de pensamiento para razonamiento
cot_messages = [
{"role": "system", "content": "Resuelve problemas matemáticos paso a paso. Muestra tu trabajo y luego da la respuesta final en la última línea como RESPUESTA: <número>."},
{"role": "user", "content": "¿Una tienda tiene 24 manzanas. Venden 3/8 de ellas. ¿Cuántas quedan?"},
]
cot = client.chat.completions.create(model="gpt-4o-mini", messages=cot_messages, temperature=0)
print(cot.choices[0].message.content)
# Clasificación few-shot
few_shot = [
{"role": "system", "content": "Clasifica los tickets de soporte como facturación, técnico o cuenta. Responde con una sola palabra."},
{"role": "user", "content": "Me cobraron dos veces este mes"},
{"role": "assistant", "content": "facturación"},
{"role": "user", "content": "La API devuelve errores 500 en POST /users"},
{"role": "assistant", "content": "técnico"},
{"role": "user", "content": "Necesito cambiar mi dirección de correo electrónico"},
]
result = client.chat.completions.create(model="gpt-4o-mini", messages=few_shot, temperature=0)
print("clasificación:", result.choices[0].message.content)
# QA Anclado - usa solo el contexto proporcionado
context = "Nuestro límite de tasa de API es de 1000 solicitudes/minuto para planes Pro y 100/minuto para planes Gratuitos."
grounded = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "Responde ÚNICAMENTE usando el contexto proporcionado. Si la respuesta no está en el contexto, di 'No tengo esa información.'"},
{"role": "user", "content": f"Contexto:\n{context}\n\nPregunta: ¿Cuál es el límite de tasa del plan Pro?"},
],
temperature=0,
)
print(grounded.choices[0].message.content)Lo que esto demuestra:
- Cadena de pensamiento con formato de respuesta explícito.
- Ejemplos few-shot que enseñan etiquetas de clasificación.
- QA Anclado que restringe las respuestas al contexto proporcionado.
temperature=0para clasificación y extracción deterministas.
Inmersión Profunda
Cómo Funciona
- Prompt del sistema establece instrucciones persistentes (rol, restricciones, formato).
- Few-shot proporciona ejemplos de entrada/salida en el historial de mensajes.
- Cadena de pensamiento pide al modelo que razone paso a paso antes de responder.
- Anclaje (Grounding) restringe las respuestas al contexto proporcionado (patrón RAG).
- Las instrucciones de formato de salida especifican estructura JSON, markdown o de puntos.
Patrones de Prompts
| Patrón | Técnica | Mejor para |
|---|---|---|
| Zero-shot | Solo instrucciones | Tareas simples y bien definidas |
| Few-shot | 2-5 ejemplos | Clasificación, extracción |
| Cadena de pensamiento | "Piensa paso a paso" | Matemáticas, lógica, razonamiento multi-paso |
| Anclado | "Usa solo este contexto" | RAG, QA factual |
| Basado en rol | "Eres un X senior" | Nivel de tono y experiencia |
Notas de Python
# Plantillas de prompts con variables
def build_review_prompt(code: str, focus: str) -> list[dict]:
return [
{"role": "system", "content": f"Eres un revisor de código centrado en {focus}."},
{"role": "user", "content": f"```python\n{code}\n```"},
]
# Almacena prompts en archivos controlados por versión
from pathlib import Path
SYSTEM_PROMPT = Path("prompts/reviewer.txt").read_text()Trampas Comunes
- Instrucciones vagas - "sé útil" produce resultados inconsistentes. Solución: rol, formato y restricciones específicos.
- Demasiados ejemplos few-shot - desperdicia tokens sin mejorar la precisión. Solución: 2-5 ejemplos diversos; recorta si el rendimiento se estanca.
- Sin especificación de formato de salida - el modelo devuelve prosa cuando necesitas JSON. Solución: formato explícito en el prompt del sistema o
response_format. - Inyección de prompt desde la entrada del usuario - los usuarios anulan las instrucciones del sistema. Solución: separa claramente el sistema/usuario; valida los resultados; usa delimitadores.
- No iterar - el primer prompt rara vez es óptimo. Solución: prueba en más de 20 ejemplos; mide la precisión antes de desplegar.
- Mezclar instrucciones y datos - el modelo confunde qué seguir y qué procesar. Solución: usa delimitadores claros (
---, etiquetas XML, secciones markdown).
Alternativas
| Alternativa | Usar cuando | No usar cuando |
|---|---|---|
| Ingeniería de prompts | Iteración rápida, sin datos de entrenamiento | Necesitas comportamiento consistente a escala |
| Fine-tuning | Miles de ejemplos etiquetados | Pocos ejemplos (usa few-shot) |
| RAG | Las respuestas necesitan datos actuales/privados | El modelo ya conoce la información |
| Salida estructurada / herramientas | Necesitas un esquema garantizado | El texto libre es aceptable |
Preguntas Frecuentes
¿Qué tan largo debe ser un prompt del sistema?
- Tan largo como sea necesario, pero cada token cuesta dinero.
- Empieza de forma concisa; añade restricciones cuando veas fallos.
- Mueve las instrucciones estables al sistema; mantén los mensajes del usuario para los datos de la tarea.
¿Qué es la cadena de pensamiento?
- Pide al modelo que muestre el razonamiento antes de la respuesta final.
- Mejora la precisión en tareas matemáticas, lógicas y multi-paso.
- Usa
temperature=0para un razonamiento reproducible.
¿Cómo prevengo la inyección de prompts?
- Nunca concatenes la entrada del usuario en los prompts del sistema.
- Usa delimitadores:
<entrada_usuario>...</entrada_usuario>. - Valida y sanitiza las salidas del modelo antes de la ejecución.
¿Debo poner ejemplos en los mensajes del sistema o del usuario?
- Los ejemplos few-shot van en pares de mensajes de usuario/asistente.
- El prompt del sistema contiene las reglas y las restricciones de formato.
¿Cómo pruebo la calidad de un prompt?
- Crea un conjunto de evaluación de 20-50 pares de entrada/salida esperada.
- Mide la precisión, no las "vibes".
- Consulta Evaluación y Guardrails.
¿Qué es el patrón ReAct?
- Razonar + Actuar: el modelo piensa, llama a una herramienta, observa el resultado, repite.
- Implementado en frameworks de agentes como LangGraph.
¿Cómo manejo entradas largas?
- Resume o divide la entrada antes de enviarla.
- Usa modelos con ventanas de contexto más grandes.
- RAG recupera solo los fragmentos relevantes.
¿Importa el orden del prompt?
- Sí - los tokens recientes tienen más influencia.
- Pon las instrucciones más importantes en el prompt del sistema.
- Coloca la tarea real al final del mensaje del usuario.
¿Cómo versiono los prompts?
- Almacénalos en archivos rastreados por git (
prompts/v2/reviewer.txt). - Registra la versión del prompt con cada llamada a la API.
- Realiza pruebas A/B de variantes de prompts en conjuntos de evaluación.
¿Cuándo debería hacer fine-tuning en su lugar?
- Miles de pares de entrada/salida consistentes.
- La ingeniería de prompts se estanca en tu conjunto de evaluación.
- Necesitas menor latencia o un modelo más pequeño con la misma calidad.
¿Qué son las etiquetas XML para prompts?
<context>{retrieved_docs}</context>
<question>{user_query}</question>- Claude y GPT responden bien a delimitadores estructurados.
¿Cómo reduzco las alucinaciones?
- Ancla con contexto recuperado (RAG).
- Instruye "di que no lo sé si no está en el contexto".
- Baja la temperatura; requiere citas.
Relacionados
- Conceptos Básicos de LLM - mensajes y roles
- Salida Estructurada - esquemas JSON
- Conceptos Básicos de RAG - respuestas ancladas
- Evaluación y Guardrails - pruebas de prompts
- Tokens, Costo y Límites de Tasa - costo de longitud del prompt
Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.