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 solucion a continuacion 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.

Cuándo usarlo

Usa esta receta cuando:

• Construyes aplicaciones que llaman APIs de LLM para clasificación, extracción o generación
• Debuggeas 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 bajo $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. Retorna 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 context 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 testearse 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 (samplear 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 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 temperatura apropiadamente: Usa temperature=0. 7+ para generación creativa.
• Valida y sanitiza outputs: los LLMs pueden alucinar, producir JSON inválido o ignorar instrucciones. Siempre parsea defensivamente y ten lógica de fallback.
• Versiona y trackea prompts: Un cambio pequeño de redacción puede alterar drásticamente la calidad del output, y necesitas poder hacer rollback.
• Testea 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 uso de tokens en turnos subsiguientes y mantiene las instrucciones consistentes.

Errores comunes

• Sobrecargar context: enviar 50 ejemplos desperdicia tokens y puede confundir al modelo. Curate los ejemplos más relevantes.
• Confiar en outputs sin validación: los LLMs generan información incorrecta con confianza. Siempre verifica hechos, especialmente en dominios de alto riesgo como medicina o finanzas.
• Ignorar límites de tokens: un prompt con 10,000 tokens deja poco espacio para la respuesta.
• No manejar rechazos: algunas queries disparan filtros de seguridad.
• Instrucciones ambiguas: “mejóralo” o “arregla esto” no le da al modelo ninguna dirección accionable. 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 setear max_tokens: Setea max_tokens según tu longitud esperada de output.
• Prompt injection desde input de usuario: ” Sanitiza y delimita el contenido del usuario.

Lectura Adicional

• Documentación oficial: consulta la referencia actualizada del framework o herramienta utilizada.
• Guías relacionadas: explora las guías de ai y machine-learning para profundizar.
• Patrones complementarios: revisa los patrones de diseño aplicables a tu stack tecnológico.
• Postmortems públicos: estudia incidentes reales de equipos que enfrentaron problemas similares en producción.

Notas de Producción

• Despliega gradualmente usando canary o blue-green para detectar regresiones temprano.
• Configura alertas para errores, latencia p99 y tasa de fallos antes de habilitar en producción.
• Documenta el rollback en el runbook; prueba el procedimiento en staging al menos una vez por trimestre.
• Revisa logs estructurados con correlation IDs para trazar requests end-to-end en incidentes.

Puntos Clave

• Aplica aplicar lo que funciona en prompt engineering cuando necesites una solución práctica para tu caso de uso.
• Monitorea el rendimiento después de implementar; mide latencia, errores y uso de recursos antes y después.
• Revisa la sección de Troubleshooting ante errores comunes; la mayoría tienen causa raíz documentada con solución.
• Mantén dependencias actualizadas y ejecuta tests en CI para prevenir regresiones en producción.

Errores comunes adicionales

• 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 no-English. Siempre testea con edge cases antes de desplegar.
• Depender de un solo modelo — los prompts son model-specific. Un prompt optimizado para GPT-4 puede producir resultados pobres en Claude o Llama. Testea across todos los modelos que planeas soportar.
• No usar stop sequences — sin stop sequences, el modelo puede continuar generando más allá del output deseado. Setea stop sequences (ej. "\n\n", "###") para terminar respuestas limpiamente.
• Ignorar el costo de few-shot examples — cada ejemplo agrega tokens a cada llamada API. Para aplicaciones de alto volumen, el costo de 5 ejemplos por llamada se acumula. Usa ejemplos cacheados o switch a fine-tuning si los costos de few-shot se vuelven significativos.
• No documentar cambios de prompt — cuando modificas un prompt, loguea el cambio, la razón y el impacto medido. Sin version control, no puedes rollbackear una regresión o entender por qué cambió la calidad.
• Usar la misma temperature para todas las tareas — clasificación necesita temperature 0, creative writing necesita 0.7+, y generación de código funciona mejor a 0.2. Usar la temperature equivocada produce resultados inconsistentes o poco creativos.
• No manejar deprecation de modelos — OpenAI y otros proveedores deprecatean modelos antiguos. Cuando un modelo es deprecado, tus prompts pueden comportarse diferente en el reemplazo. Testea prompts contra modelos nuevos antes de switchear.
• Sobrecargar system prompts — un system prompt de 500 palabras con 20 reglas es más difícil de seguir para el modelo que un prompt de 100 palabras con 5 reglas clave. Sé conciso y prioriza las instrucciones más importantes.

Buenas Prácticas

• Versiona tus prompts: Taggea cada despliegue con la versión de prompt usada. Esto te permite correlacionar cambios de calidad con modificaciones de prompt.
• Construye un use de evaluación de prompts: Ejecútalo antes y después de cualquier cambio de prompt. Esto detecta regresiones antes de que lleguen a producción.
• 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.
• Setea A/B testing de prompts: Promueve el ganador solo después de resultados estadísticamente significativos.
• Cachea respuestas para prompts determinísticos: si el mismo prompt + input siempre produce el mismo output (temperature=0), cachea la respuesta.
• Monitorea prompt drift: Si la calidad degrada sin ningún cambio de prompt, el modelo subyacente puede haber sido actualizado silenciosamente.
• Usa formatos de output estructurados: solicita output JSON, XML o YAML en lugar de texto libre cuando necesites parsear la respuesta programáticamente. Esto reduce fallos de parsing y habilita validación.
• Setea políticas de timeout y retry: las llamadas API pueden colgarse o fallar. Setea un timeout (ej. , 30 segundos) y reintenta con backoff exponencial. Fallea a una respuesta cacheada o default después de max retries.
• Loguea pares completos de request/response: Esto es esencial para debugging, auditoría y mejora de prompts a lo largo del tiempo.

Troubleshooting

• Model outputs are inconsistent: set temperature to 0 for deterministic tasks, use seed where supported, and version the prompt.
• Prompt injection leaks context: separate user input from system instructions.
• High token costs: cache embeddings, summarize long context, and choose smaller models for simple tasks.
• Retrieval returns irrelevant chunks: tune chunk size, overlap, and metadata filters. Evaluate retrieval metrics separately from generation.
• Evaluation scores do not match human judgment: Human review is still the ground truth.

Errores Comunes en Producción

• Copiar el ejemplo sin adaptarlo a volúmenes y modos de fallo reales.
• Saltar tests de carga e inyección de errores antes del primer despliegue productivo.
• Codificar valores fijos que deberían ser configurables por entorno.
• Olvidar agregar logging y monitoreo en cada paso.
• Desplegar sin plan de rollback ni estrategia de backup probada.
• Asumir que el ejemplo mínimo escalará sin agregar caché o procesamiento por lotes.
• No documentar la versión y configuración usadas en producción.
• Dejar la receta sin cambios cuando evolucionan las dependencias o la escala.