Técnicas fundamentales de ingeniería de prompts

La ingeniería de prompts (o Prompt Engineering) incluye una variedad de técnicas y metodologías destinadas a optimizar la interacción con grandes modelos de lenguaje (LLM) para obtener los resultados deseados. Estas técnicas se refieren a la estructuración de las consultas, la provisión de contexto, la gestión del estilo de salida y la mejora de la capacidad de razonamiento del modelo. Dado que los LLM generan una respuesta prediciendo los siguientes tokens basándose en el prompt de entrada, la calidad y estructura de este prompt influyen directamente en el resultado. Las técnicas fundamentales de la ingeniería de prompts permiten a los desarrolladores y usuarios gestionar eficazmente el comportamiento del modelo, reducir errores y adaptarlo a tareas específicas sin necesidad de modificar los parámetros internos del modelo.

Principios básicos y estructura del prompt

Aunque las implementaciones específicas varían, los prompts eficaces a menudo se construyen teniendo en cuenta principios y estructuras comunes:

• Puntos de referencia empíricos: Como una de las estructuras prácticas (aunque no un estándar de la industria), se sugiere seguir los siguientes principios: Dar Dirección, Especificar Formato, Proporcionar Ejemplos, Evaluar Calidad y Dividir la Tarea.
• Un prompt eficaz suele incluir los siguientes componentes:
  • Introducción/Rol: Establece el contexto de la tarea o el rol/persona del modelo.
  • Instrucciones: Indicaciones claras sobre lo que se debe hacer.
  • Contexto: Información necesaria (estática o extraída dinámicamente a través de RAG).
  • Ejemplos (Few-shot): Demostración del formato/estilo deseado.
  • Solicitud de respuesta: Indicación explícita de lo que el modelo debe generar.

• Mensaje del sistema (System Prompt): En las interfaces de chat de las API (por ejemplo, en los modelos de OpenAI, Anthropic), permite establecer instrucciones globales y un rol para toda la sesión.
• Formato: El uso de Markdown, JSON, XML o YAML ayuda a estructurar el prompt y facilita el análisis de la respuesta. Los delimitadores (```, `"""`, etiquetas XML) son importantes para separar las instrucciones de los datos.

Técnicas principales para instrucciones y ejemplos

• Instrucciones claras y específicas: Describir la tarea, el resultado deseado y las limitaciones con la mayor precisión posible. Evitar la ambigüedad.
• Modelado de roles (Role Prompting): Asignar al modelo un rol ("Eres un experto en...") para gestionar el tono, el estilo y la base de conocimientos.
• Zero-shot Prompting: Una solicitud sin ejemplos. Es eficaz para tareas simples o que el modelo conoce bien.
• Few-Shot Prompting: Proporcionar varios (generalmente de 2 a 5) ejemplos de "pregunta-respuesta" para demostrar la tarea. Un caso particular es el One-shot Prompting con un solo ejemplo. Es especialmente útil para formatos o estilos complejos. Requiere precaución para evitar el sesgo (anchoring) o la captura de patrones falsos de los ejemplos.

Técnicas de gestión de contexto

• Retrieval-Augmented Generation (RAG): Adición dinámica de información relevante de bases de conocimiento externas al prompt antes de enviarlo al LLM. Propuesto por primera vez por Meta AI en 2020, este método es clave para combatir las alucinaciones y garantizar la actualidad de los datos.
• Segmentación (Chunking): Dividir textos grandes en partes más pequeñas (chunks) para que quepan en la ventana de contexto del modelo. Las estrategias incluyen la división por oraciones, párrafos o tokens (con superposición).
• Resumen: Comprimir textos largos o historiales de diálogo para transmitir el significado principal en un contexto limitado.

Técnicas para mejorar el razonamiento (Reasoning)

Estas técnicas están dirigidas a hacer que el modelo "piense" de manera más cuidadosa y estructurada. La eficacia de muchas de ellas, especialmente CoT, se manifiesta en modelos a gran escala (generalmente con más de 100 mil millones de parámetros).

• Chain-of-Thought (CoT): Instruir al modelo para que genere un razonamiento paso a paso antes de dar la respuesta final. Mejora significativamente los resultados en matemáticas, lógica y tareas de varias etapas.
  • Zero-shot CoT: La forma más simple, que no requiere ejemplos. Añadir al prompt una frase como «Pensemos paso a paso» (Let's think step by step) ya puede iniciar una cadena de razonamiento.
• Variaciones de CoT:
  • Auto-CoT: Generación automática de ejemplos de razonamiento para el prompting de tipo few-shot.
  • Self-Consistency: Generar varias cadenas de razonamiento y seleccionar la respuesta más frecuente mediante "votación", lo que aumenta la fiabilidad.
  • Tree-of-Thoughts (ToT): Explorar múltiples rutas de razonamiento en forma de árbol, con la posibilidad de retroceder y evaluar pasos intermedios. Esta técnica demuestra una alta eficacia en tareas complejas, por ejemplo, aumentando la tasa de éxito en la resolución del "Juego del 24" de ~4% a ~74%.
  • Graph-of-Thought (GoT), LogiCoT y otras, orientadas a razonamientos más complejos o verificados lógicamente.
• ReAct (Reason and Act): Una técnica que amplía CoT. Consiste en un ciclo iterativo donde el modelo alterna entre pasos de Razonamiento (Thought) y Acciones utilizando Herramientas (Act), actualizando su comprensión en función de las Observaciones (Observation).
• Self-Refine: Un proceso iterativo en el que el modelo primero genera una respuesta, luego la critica y, finalmente, la mejora basándose en su propia crítica. Este ciclo de "generación-crítica-mejora" puede repetirse varias veces.
• Take a Step Back Prompting: El modelo primero formula principios generales o abstracciones, y luego los aplica a la tarea específica.

Técnicas avanzadas: agentes y herramientas

• Uso de herramientas (Tool Usage) / Llamada a funciones (Function Calling): Proporcionar al LLM la capacidad de llamar a API externas (búsqueda, calculadora, base de datos). El modelo genera una solicitud estructurada para llamar a la herramienta, que es ejecutada por la aplicación, y el resultado se devuelve al modelo. Los LLM modernos (GPT-4, Claude 3) tienen soporte integrado para esta función.
• Agentes (Agents): Sistemas basados en LLM que pueden planificar, usar herramientas y actuar de forma autónoma para alcanzar un objetivo. A menudo utilizan ciclos similares a ReAct. Frameworks como LangChain, AutoGen o CrewAI simplifican su creación.
• Sistemas multiagente: Interacción de varios agentes especializados para resolver tareas complejas.

Técnicas para la reducción de errores y alucinaciones

• RAG: Vincular las respuestas a datos fácticos extraídos.
• Instrucciones para limitar la respuesta: Exigir que se responda únicamente con base en el contexto proporcionado o que se indique incertidumbre ("Si la respuesta es desconocida, di 'No lo sé'").
• Solicitud de citas: Requerir que el modelo cite las fuentes o partes del contexto en las que se basa la respuesta.
• Verificación y autocrítica: Utilizar técnicas como Chain-of-Verification (CoVe) (generación de una respuesta seguida de su verificación y corrección), Self-Refine o solicitar directamente al modelo que revise su propia respuesta en busca de errores.
• CoT: El razonamiento paso a paso puede reducir por sí mismo los errores lógicos.

Técnicas de evaluación e iteración

Aunque la evaluación es un proceso separado, algunos de sus aspectos forman parte de la ingeniería de prompts:

• Pruebas A/B de prompts: Comparar la eficacia de diferentes versiones de prompts en las mismas tareas.
• Uso de LLM para la evaluación: Aplicar un modelo potente (por ejemplo, GPT-4) para evaluar la calidad de las respuestas generadas por otro prompt o modelo (LLM-as-a-Judge).

Patrones de prompts

Estructuras reutilizables comunes:

• Patrón de Persona (Persona Pattern).
• Patrón de Personalización de Salida (Output Customization Pattern).
• Patrón de Refinamiento de Preguntas (Question Refinement Pattern).
• Patrón de Verificador Cognitivo / Autocrítica (Cognitive Verifier / Self-Critique Pattern).
• Patrón de Razonamiento Paso a Paso (Step-by-Step / Chain-of-Thought Pattern).
• Patrón de Plantilla (Template Pattern).

Bibliografía

• Radford, A. et al. (2019). Language Models are Unsupervised Multitask Learners. PDF.
• Brown, T. B. et al. (2020). Language Models are Few-Shot Learners. arXiv:2005.14165.
• Lewis, P. et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. arXiv:2005.11401.
• Li, X. L.; Liang, P. (2021). Prefix-Tuning: Optimizing Continuous Prompts for Generation. arXiv:2101.00190.
• Liu, Y. et al. (2021). Fantastically Ordered Prompts and Where to Find Them: Overcoming Few-Shot Prompt Order Sensitivity. arXiv:2104.08786.
• Bai, Y. et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073.
• Wei, J. et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903.
• Wang, X. et al. (2022). Self-Consistency Improves Chain of Thought Reasoning in Language Models. arXiv:2203.11171.
• Kojima, T. et al. (2022). Large Language Models are Zero-Shot Reasoners. arXiv:2205.11916.
• Zhang, Z. et al. (2022). Automatic Chain of Thought Prompting in Large Language Models. arXiv:2210.03493.
• Zhou, D. et al. (2022). Least-to-Most Prompting Enables Complex Reasoning in Large Language Models. arXiv:2205.10625.
• Yao, S. et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.
• Besta, M. et al. (2023). Graph of Thoughts: Solving Elaborate Problems with Large Language Models. arXiv:2308.09687.
• Madaan, A. et al. (2023). Self-Refine: Iterative Refinement with Self-Feedback. arXiv:2303.17651.
• Schick, T. et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. arXiv:2302.04761.
• Rafailov, R. et al. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. arXiv:2305.18290.
• Wang, Y. et al. (2023). Self-Instruct: Aligning Language Models with Self-Generated Instructions. arXiv:2212.10560.
• Yao, S. et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601.
• Chen, S. Y. et al. (2023). Extending Context Window of Large Language Models via Positional Interpolation. arXiv:2306.15595.
• Chang, K. et al. (2024). Efficient Prompting Methods for Large Language Models: A Survey. arXiv:2404.01077.
• Genkina, D. (2024). AI Prompt Engineering Is Dead. IEEE Spectrum. [1].
• Li, Z. et al. (2024). Prompt Compression for Large Language Models: A Survey. arXiv:2410.12388.
• Liang, X. et al. (2024). Internal Consistency and Self-Feedback in Large Language Models: A Survey. arXiv:2407.14507.
• Han, H. et al. (2025). Retrieval-Augmented Generation with Graphs (GraphRAG). arXiv:2501.00309.
• Li, W. et al. (2025). A Survey of Automatic Prompt Engineering: An Optimization Perspective. arXiv:2502.11560.
• Wu, Z. et al. (2025). The Dark Side of Function Calling: Pathways to Jailbreaking Large Language Models. EMNLP 2025. PDF.
• Yang, B. et al. (2025). Hallucination Detection in Large Language Models with Metamorphic Relations. arXiv:2502.15844.

Véase también

• Large language models
• Chain-of-Thought Prompting
• Alucinaciones y respuestas incorrectas de los LLM