Aplicar lo que funciona en Prompt Engineering

Visión general

Los Large Language Models (LLMs) son motores de razonamiento de propósito general, pero la calidad de sus outputs depende fuertemente de cómo formules la pregunta. El prompt engineering es la práctica de estructurar inputs para guiar el modelo hacia respuestas precisas, relevantes y bien formateadas. Cambios pequeños en la redacción pueden significar la diferencia entre un párrafo vago y un objeto JSON preciso.

La solución a continuación cubre las técnicas más confiables: asignación de rol, few-shot examples, razonamiento chain-of-thought y restricción de formato de salida. Estas técnicas funcionan en GPT-4, Claude, Gemini y modelos open-source como Llama.

He pasado más tiempo del que me gustaría admitir depurando problemas de “el modelo está roto” que resultaron ser un ejemplo faltante o una instrucción ambigua en el prompt.

Cuándo usarlo

Usa esta receta cuando:

• Construyes aplicaciones que llaman APIs de LLM para clasificación, extracción o generación
• Depuras outputs inconsistentes o alucinados del modelo
• Diseñas chatbots, copilotos o asistentes impulsados por IA
• Implementando pipelines automatizados de moderación de contenido, resumen o traducción
• Evaluando versiones de prompts con frameworks de testing A/B

Solución

Asignación de Rol (System Prompt)

import openai

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "Eres un revisor senior de código Python. Sé conciso, enfócate en problemas de seguridad y rendimiento."},
        {"role": "user", "content": "Revisa esta función: def login(email, password): ..."}
    ]
)

Few-Shot Examples

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "Clasifica la intención del usuario en: SEARCH, SUPPORT, BILLING u OTHER."},
        {"role": "user", "content": "¿Cómo reseteo mi contraseña?"},
        {"role": "assistant", "content": "SUPPORT"},
        {"role": "user", "content": "Encuéntrame zapatillas rojas por menos de $100"},
        {"role": "assistant", "content": "SEARCH"},
        {"role": "user", "content": "Me cobraron dos veces el mes pasado"},
        {"role": "assistant", "content": "BILLING"},
        {"role": "user", "content": user_input},
    ]
)

Chain-of-Thought Reasoning

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "Resuelve problemas de matemáticas paso a paso. Muestra tu razonamiento, luego da la respuesta final en la última línea con prefijo RESPUESTA:"},
        {"role": "user", "content": "Si un tren viaja 120 km en 2 horas, ¿qué distancia recorrerá en 5 horas a la misma velocidad?"}
    ]
)

Salida JSON Estructurada

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "Extrae entidades del texto. Responde SOLO con JSON válido que coincida con este schema: {\"person\": string, \"organization\": string, \"location\": string}"},
        {"role": "user", "content": "Elon Musk anunció que Tesla construirá una nueva fábrica en México."}
    ],
    response_format={"type": "json_object"}
)

Function Calling (Uso de Herramientas)

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "¿Qué clima hace en Tokio ahora mismo?"}
    ],
    tools=[{
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtener el clima actual de una ciudad",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nombre de la ciudad"}
                },
                "required": ["city"]
            }
        }
    }],
    tool_choice="auto"
)

# El modelo devuelve un tool_call; lo ejecutas y envías el resultado de vuelta
tool_call = response.choices[0].message.tool_calls[0]
# Ejecuta get_weather("Tokio") en tu código, luego envía el resultado

Go (usando langchaingo)

package main

import (
    "context"
    "fmt"
    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/openai"
)

func main() {
    llm, err := openai.New()
    if err != nil {
        panic(err)
    }

    ctx := context.Background()
    resp, err := llms.GenerateFromSinglePrompt(ctx, llm,
        "Eres un revisor de código. Revisa esta función por problemas de seguridad.\n"+
        "func login(email, password string) error { ... }",
        llms.WithTemperature(0),
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(resp)
}

Prompt Chaining (Pipeline Multi-Step)

# Paso 1: Extraer temas clave de un documento
extract_response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "Extrae 3-5 temas clave del texto como un array JSON de strings."},
        {"role": "user", "content": long_document_text}
    ],
    response_format={"type": "json_object"}
)
topics = extract_response.choices[0].message.content

# Paso 2: Generar un resumen para cada tema
summary_response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "Escribe un resumen de 2 frases para cada tema proporcionado. Devuelve como JSON: {tema: resumen}."},
        {"role": "user", "content": topics}
    ],
    response_format={"type": "json_object"}
)

Explicación

• Asignación de rol: Los LLMs adaptan tono, profundidad y formato basado en la persona que asignas. Un “experto legal” da diferente consejo que un “tutor amigable” para la misma pregunta.
• Few-shot learning: Proporcionar ejemplos de input/output en el contexto enseña al modelo tu formato esperado sin fine-tuning. Tres a cinco ejemplos usualmente bastan.
• Chain-of-thought: Pedir explícitamente al modelo que razone paso a paso mejora dramáticamente la precisión en tareas complejas (matemáticas, lógica, planificación multi-paso). También facilita el debugging porque puedes ver dónde falló el razonamiento.
• Salida estructurada: Restringir respuestas a JSON, XML o formatos específicos elimina errores de parsing y hace que el procesamiento downstream sea confiable.
• Function calling: En lugar de parsear respuestas en texto libre para determinar acciones, el modelo devuelve tool calls estructurados con parámetros tipados. Tu código ejecuta la función y alimenta los resultados de vuelta, creando un loop de feedback para workflows agénticos.
• Prompt chaining: Dividir tareas complejas en pasos secuenciales (extraer → resumir → formatear) produce mejores resultados que un solo mega-prompt. Cada paso recibe contexto enfocado y puede probarse independientemente.

Variantes

Técnica	Caso de uso	Impacto en costo
Zero-shot	Clasificación simple, Q&A	Bajo tokens
Few-shot	Extracción específica de formato	Tokens medio
Chain-of-thought	Razonamiento complejo, matemáticas	Más tokens
Function calling	Uso de herramientas, integración API	Tokens medio
Prompt chaining	Pipelines multi-step	Más tokens (múltiples llamadas)
Self-consistency	Matemáticas, lógica (muestrear N veces, mayoría)	N× costo
ReAct (Razonar+Actuar)	Workflows agénticos con herramientas	Alto tokens

Lo que funciona

• Sé específico y explícito: los prompts vagos producen respuestas vagas. En lugar de “resume esto,” di “resume en 3 bullets enfocándote en el impacto financiero.”
• Usa delimitadores para inputs largos: envuelve el contenido del usuario en tags XML (<article>...</article>) o triples backticks para que el modelo distinga instrucciones de datos.
• Configura la temperatura apropiadamente: usa temperature=0 para tareas determinísticas (clasificación, extracción) y 0.7+ para generación creativa.
• Valida y sanitiza los outputs: los LLMs pueden alucinar, producir JSON inválido o ignorar instrucciones. Parsea siempre de forma defensiva y ten lógica de fallback.
• Versiona y rastrea los prompts: un cambio pequeño de redacción puede alterar drásticamente la calidad del output, y necesitas poder hacer rollback.
• Prueba con múltiples modelos: un prompt que funciona en GPT-4 puede fallar en Llama o Claude.
• Usa system prompts para instrucciones fijas: pon rol, formato y restricciones en el mensaje del sistema en lugar del mensaje del usuario. Esto reduce el uso de tokens en turnos subsiguientes y mantiene las instrucciones consistentes.
• Construye una suite de evaluación de prompts: crea un script que ejecute un prompt contra un test set de 20-50 inputs y reporte tasas de pass/fail. Ejecútalo antes y después de cualquier cambio de prompt — así detectas regresiones antes de que lleguen a producción. Hay una versión ejecutable en el repo complementario.
• Usa prompts separados para tareas separadas: un solo prompt que intenta clasificar, resumir y extraer entidades hará las tres cosas mal. Divide en llamadas API separadas con prompts enfocados.
• Guarda en caché respuestas para prompts determinísticos: si el mismo prompt + input siempre produce el mismo output (temperature=0), guarda en caché la respuesta para eliminar llamadas API redundantes.
• Monitoriza el drift de prompts: rastrea métricas de calidad del output a lo largo del tiempo. Si la calidad degrada sin ningún cambio de prompt, el modelo subyacente puede haber sido actualizado silenciosamente.
• Registra pares completos de request/response: guarda el prompt completo, modelo, parámetros y respuesta de cada llamada API — esencial para debugging, auditoría y mejora de prompts a lo largo del tiempo.

Errores comunes

• Sobrecargar el contexto: enviar 50 ejemplos desperdicia tokens y puede confundir al modelo. Selecciona los ejemplos más relevantes.
• Confiar en los outputs sin validación: los LLMs devuelven respuestas incorrectas con total confianza. Verifica siempre los hechos, especialmente en dominios de alto riesgo como medicina o finanzas.
• Ignorar los límites de tokens: un prompt que consume 10,000 tokens apenas deja espacio para que el modelo responda.
• No manejar los rechazos: algunas queries disparan filtros de seguridad. Tu aplicación debería manejar con gracia los rechazos y las respuestas parciales.
• Instrucciones ambiguas: “mejóralo” o “arregla esto” no le dice nada accionable al modelo. Especifica qué significa “mejor” — más corto, más formal, conforme a una guía de estilo.
• Formato inconsistente en few-shot: si tus ejemplos usan patrones de formato diferentes, el modelo se confunde.
• No establecer max_tokens: sin un límite, el modelo puede generar respuestas excesivamente largas, aumentando costo y latencia. Establece max_tokens según tu longitud esperada de output.
• Prompt injection desde input de usuario: si tu prompt incluye texto generado por el usuario, un usuario malicioso puede inyectar instrucciones como “ignora todas las instrucciones anteriores.” Sanitiza y delimita el contenido del usuario.
• No testear edge cases: los prompts que funcionan en inputs típicos pueden fallar en strings vacíos, texto muy largo, caracteres especiales o input en otros idiomas.
• No usar stop sequences: sin ellas, el modelo puede seguir generando más allá del output deseado. Establece stop sequences (ej. "\n\n", "###") para terminar respuestas limpiamente.
• Ignorar el costo de few-shot examples: cada ejemplo agrega tokens a cada llamada API — en aplicaciones de alto volumen, 5 ejemplos por llamada se acumulan rápido.
• Usar la misma temperature para todas las tareas: clasificación necesita temperature=0, escritura creativa necesita 0.7+, y generación de código funciona mejor a 0.2.
• No manejar la deprecación de modelos: los proveedores deprecan modelos antiguos y tus prompts pueden comportarse diferente en el reemplazo. Prueba los prompts contra modelos nuevos antes de cambiar.
• Sobrecargar los system prompts: un system prompt de 500 palabras con 20 reglas es más difícil de seguir que uno de 100 palabras con 5 reglas clave.

Solución de problemas

• Los outputs del modelo son inconsistentes: establece temperature=0 para tareas determinísticas, usa seed donde sea soportado y versiona el prompt.
• El prompt injection filtra contexto: separa el input del usuario de las instrucciones del sistema con delimitadores; trata el contenido del usuario como datos, nunca como comandos.
• Costos altos de tokens: guarda en caché las respuestas para inputs idénticos, acorta los system prompts y usa modelos más pequeños (GPT-4o-mini) para tareas simples.
• El JSON de salida está malformado: activa response_format={"type": "json_object"} y valida el schema server-side — el modelo aún puede producir valores semánticamente incorrectos.
• Los few-shot examples son ignorados: verifica que tus ejemplos usen formato consistente; los patrones inconsistentes confunden al modelo más de lo que ayudan.