Técnicas Fundamentais de Engenharia de Prompt

A Engenharia de Prompt (Prompt Engineering) inclui uma variedade de técnicas e metodologias destinadas a otimizar a interação com modelos de linguagem grandes (LLMs) para obter os resultados desejados. Essas técnicas abrangem a estruturação de solicitações, o fornecimento de contexto, o gerenciamento do estilo de saída e a melhoria da capacidade de raciocínio do modelo. Como os LLMs geram respostas prevendo os próximos tokens com base no prompt de entrada, a qualidade e a estrutura desse prompt influenciam diretamente o resultado. As técnicas fundamentais de engenharia de prompt permitem que desenvolvedores e usuários controlem eficazmente o comportamento do modelo, reduzam erros e o adaptem a tarefas específicas sem a necessidade de alterar os parâmetros internos do modelo.

Princípios básicos e estrutura do prompt

Embora as implementações específicas variem, prompts eficazes são frequentemente construídos com base em princípios e estruturas comuns:

• Diretrizes empíricas: Como uma das estruturas práticas (mas não um padrão da indústria), sugere-se seguir os seguintes princípios: Dar Direção, Especificar o Formato, Fornecer Exemplos, Avaliar a Qualidade e Dividir a Tarefa.
• Um prompt eficaz frequentemente inclui os seguintes componentes:
  • Introdução/Papel: Define o contexto da tarefa ou o papel/persona do modelo.
  • Instruções: Orientações claras sobre o que deve ser feito.
  • Contexto: Informações necessárias (estáticas ou extraídas dinamicamente via RAG).
  • Exemplos (Few-shot): Demonstração do formato/estilo desejado.
  • Solicitação da resposta: Indicação explícita do que o modelo deve gerar.

• Mensagem de sistema (System Prompt): Em interfaces de chat de APIs (por exemplo, nos modelos da OpenAI, Anthropic), permite definir instruções globais e um papel para toda a sessão.
• Formatação: O uso de Markdown, JSON, XML ou YAML ajuda a estruturar o prompt e facilita a análise (parsing) da resposta. Delimitadores (```, `"""`, tags XML) são importantes para separar as instruções dos dados.

Técnicas principais de instruções e exemplos

• Instruções claras e específicas: Descrever a tarefa, o resultado desejado e as restrições com a máxima precisão. Evitar ambiguidades.
• Modelagem de papel (Role Prompting): Atribuir um papel ao modelo ("Você é um especialista em...") para controlar o tom, o estilo e a base de conhecimento.
• Prompting Zero-shot: Uma solicitação sem exemplos. Eficaz para tarefas simples ou bem conhecidas pelo modelo.
• Prompting Few-Shot: Fornecer alguns (geralmente de 2 a 5) exemplos de "pergunta-resposta" para demonstrar a tarefa. Um caso particular é o Prompting One-shot, com um único exemplo. É especialmente útil para formatos ou estilos complexos. Requer cuidado para evitar viés (anchoring) ou a captura de padrões falsos a partir dos exemplos.

Técnicas de gerenciamento de contexto

• Retrieval-Augmented Generation (RAG): Adição dinâmica de informações relevantes de bases de conhecimento externas ao prompt antes de enviá-lo ao LLM. Proposto pela primeira vez pela Meta AI em 2020, este método é fundamental para combater alucinações e garantir a atualidade dos dados.
• Chunking (Divisão em blocos): Divisão de textos longos em partes menores (chunks) para se ajustar à janela de contexto do modelo. As estratégias incluem a divisão por sentenças, parágrafos ou tokens (com sobreposição).
• Sumarização: Compressão de textos longos ou históricos de diálogo para transmitir o sentido principal em um contexto limitado.

Técnicas de melhoria de raciocínio (Reasoning)

Essas técnicas visam fazer com que o modelo "pense" de forma mais cuidadosa e estruturada. A eficácia de muitas delas, especialmente a CoT, é evidente em modelos de grande escala (geralmente com mais de 100 bilhões de parâmetros).

• Chain-of-Thought (CoT): Instruir o modelo a gerar um raciocínio passo a passo antes da resposta final. Melhora significativamente os resultados em matemática, lógica e tarefas com múltiplas etapas.
  • CoT Zero-shot: A forma mais simples, que não requer exemplos. Adicionar ao prompt uma frase como "Vamos pensar passo a passo" (Let's think step by step) já pode iniciar a cadeia de raciocínio.
• Variações da CoT:
  • Auto-CoT: Geração automática de exemplos de raciocínio para o prompting few-shot.
  • Self-Consistency: Geração de múltiplas cadeias de raciocínio e seleção da resposta mais frequente por meio de "votação", o que aumenta a confiabilidade.
  • Tree-of-Thoughts (ToT): Exploração de múltiplos caminhos de raciocínio em forma de árvore, com a possibilidade de retroceder e avaliar passos intermediários. Esta técnica demonstra alta eficácia em tarefas complexas, por exemplo, aumentando a taxa de sucesso na resolução do "Game of 24" de ~4% para ~74%.
  • Graph-of-Thought (GoT), LogiCoT e outras, focadas em raciocínios mais complexos ou logicamente verificados.
• ReAct (Reason and Act): Uma técnica que expande a CoT. Consiste em um ciclo iterativo onde o modelo alterna entre passos de Raciocínio (Thought) e Ações usando Ferramentas (Act), atualizando sua compreensão com base em Observações (Observation).
• Self-Refine: Um processo iterativo no qual o modelo primeiro gera uma resposta, depois a critica e, finalmente, a aprimora com base em sua própria crítica. Este ciclo de "geração-crítica-melhoria" pode ser repetido várias vezes.
• Take a Step Back Prompting: O modelo primeiro formula princípios gerais ou abstrações e, em seguida, os aplica à tarefa específica.

Técnicas avançadas: agentes e ferramentas

• Uso de Ferramentas (Tool Usage) / Chamada de Função (Function Calling): Fornecer ao LLM a capacidade de chamar APIs externas (busca, calculadora, banco de dados). O modelo gera uma solicitação estruturada para chamar a ferramenta, que é executada pela aplicação, e o resultado é retornado ao modelo. LLMs modernos (GPT-4, Claude 3) possuem suporte nativo para essa funcionalidade.
• Agentes (Agents): Sistemas baseados em LLMs que podem planejar, usar ferramentas e agir autonomamente para atingir um objetivo. Frequentemente, utilizam ciclos semelhantes ao ReAct. Frameworks (LangChain, AutoGen, CrewAI) simplificam sua criação.
• Sistemas multiagentes: Interação de vários agentes especializados para resolver tarefas complexas.

Técnicas para redução de erros e alucinações

• RAG: Vincular as respostas a dados factuais recuperados.
• Instruções para limitar a resposta: Exigir que o modelo responda apenas com base no contexto fornecido ou indique incerteza ("Se a resposta for desconhecida, diga 'Não sei'").
• Solicitação de citação: Exigir que o modelo indique fontes ou cite partes do contexto nas quais a resposta se baseia.
• Verificação e autocrítica: Uso de técnicas como Chain-of-Verification (CoVe) (geração de uma resposta seguida de sua verificação e correção), Self-Refine ou uma solicitação direta para que o modelo verifique sua própria resposta em busca de erros.
• CoT: O raciocínio passo a passo, por si só, pode reduzir erros lógicos.

Técnicas de avaliação e iteração

Embora a avaliação seja um processo separado, alguns de seus aspectos fazem parte da engenharia de prompt:

• Teste A/B de prompts: Comparação da eficácia de diferentes versões de prompts nas mesmas tarefas.
• Uso de LLM para avaliação: Aplicação de um modelo poderoso (por exemplo, GPT-4) para avaliar a qualidade das respostas geradas por outro prompt ou modelo (LLM-as-a-Judge).

Padrões de prompt

Estruturas reutilizáveis comuns:

• Padrão de Persona (Persona Pattern).
• Padrão de Customização de Saída (Output Customization Pattern).
• Padrão de Refinamento de Pergunta (Question Refinement Pattern).
• Padrão de Verificador Cognitivo / Autocrítica (Cognitive Verifier / Self-Critique Pattern).
• Padrão de Raciocínio Passo a Passo (Step-by-Step / Chain-of-Thought Pattern).
• Padrão de Modelo (Template Pattern).

Literatura

• 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.

Ver também

• Modelos de linguagem grandes
• Chain-of-Thought Prompting
• Alucinações e respostas incorretas de LLMs