Padrão de solicitação com cabeçalho, corpo e rodapé
Estrutura consistente de solicitação que se adapta a solicitações complexas com várias tarefas.
Padrão de solicitação com cabeçalho, corpo e rodapé é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.
Prompts como documentos
Documentos extensos — relatórios, artigos e e-mails — usam uma estrutura de Cabeçalho/Corpo/Rodapé porque ela é cognitivamente fácil de percorrer. Os leitores sabem o que esperar em cada área.
O mesmo princípio se aplica aos prompts. Quando eles ultrapassam algumas frases, uma estrutura de Cabeçalho/Corpo/Rodapé facilita a consulta rápida, a manutenção e a consistência.
Esse padrão funciona em diferentes modelos e pode ser aplicado desde prompts simples até prompts altamente complexos.
A seção de cabeçalho
O Cabeçalho responde a duas perguntas: Quem é você? e Qual é a tarefa?
Ele define a identidade do modelo (persona ou função) e declara o objetivo principal do prompt. Todo o restante se baseia nessa fundação.
Um cabeçalho eficaz é conciso — normalmente tem de 2 a 4 frases. Ele não inclui exemplos, restrições nem regras da saída.
header = '''
<header>
You are an expert technical writer specializing in API documentation.
Your task is to write clear, developer-friendly documentation
for the API endpoint described in the body of this prompt.
</header>
'''
print(header)A seção do corpo
O Corpo contém o conteúdo ou contexto de que o modelo precisa para executar a tarefa. Esta é a principal área de dados:
- Documentos de origem a serem processados
- Histórico da conversa
- Dados estruturados (trechos de JSON e CSV)
- Material de referência
- A entrada real do usuário
O corpo é a maior seção e, na maioria das vezes, é inserido dinamicamente em tempo de execução.
def build_body(endpoint_spec):
return f'''
<body>
<endpoint_specification>
{endpoint_spec}
</endpoint_specification>
</body>
'''
spec = 'POST /api/v2/users\nRequest body: {email: string, role: admin|user}\nReturns: {id: string, created_at: ISO8601}'
print(build_body(spec))A seção do rodapé
O Rodapé contém as instruções de formatação e o esquema da saída. Ele aparece por último porque:
- O modelo lê de cima para baixo e aplica as regras de formatação ao que acabou de processar
- As instruções de formatação próximas ao final têm menos probabilidade de ser ignoradas
- O rodapé costuma ser reutilizável entre prompts com o mesmo tipo de saída
O rodapé deve ser explícito: Retorne um objeto JSON com estes campos, e não formate bem.
footer = '''
<footer>
Format your response as a JSON object with these fields:
{
"endpoint": "string",
"summary": "string (one sentence)",
"parameters": [{"name": "string", "type": "string", "required": true|false, "description": "string"}],
"response_example": "string (JSON)",
"error_codes": [{"code": "number", "meaning": "string"}]
}
Do not include any text outside the JSON object.
</footer>
'''
print(footer)Montando o padrão completo
Combinando o Cabeçalho, o Corpo e o Rodapé em uma função de prompt completa e reutilizável:
def build_api_doc_prompt(endpoint_spec):
header = '<header>\nYou are an expert technical writer. Document the API endpoint in the body.\n</header>'
body = f'<body>\n<endpoint>\n{endpoint_spec}\n</endpoint>\n</body>'
footer = '<footer>\nReturn JSON: {"summary": str, "parameters": [...], "response_example": str}\nNo text outside JSON.\n</footer>'
return '\n\n'.join([header, body, footer])
spec = 'GET /api/products/:id\nReturns product details by ID'
print(build_api_doc_prompt(spec))Por que essa ordem funciona
A ordem Cabeçalho/Corpo/Rodapé corresponde à forma como os modelos processam o contexto:
- Cabeçalho primeiro — estabelece a identidade e o objetivo, preparando o modelo para o que vem a seguir
- Corpo em segundo — o modelo então processa o conteúdo por meio da perspectiva da função e da tarefa estabelecidas
- Rodapé por último — as instruções de formatação aparecem imediatamente antes de o modelo gerar sua resposta, maximizando sua influência sobre a estrutura da saída
Colocar as instruções de formatação no cabeçalho (primeiro) faz com que elas sejam parcialmente esquecidas quando o modelo escreve sua resposta.
Escalonamento para Instruções Complexas
O padrão Cabeçalho/Corpo/Rodapé se adapta naturalmente quando as instruções se tornam complexas:
def build_complex_prompt(persona, task, context_docs, constraints, output_schema):
header = f'<header>\n{persona}\nTask: {task}\n</header>'
docs = '\n'.join(f'<document id="{i+1}">\n{d}\n</document>' for i, d in enumerate(context_docs))
body = f'<body>\n{docs}\n</body>'
constraint_list = '\n'.join(f'- {c}' for c in constraints)
footer = f'<footer>\n<constraints>\n{constraint_list}\n</constraints>\n<output_schema>\n{output_schema}\n</output_schema>\n</footer>'
return '\n\n'.join([header, body, footer])Reutilizando Modelos de Rodapé
Como o rodapé define a estrutura da saída, ele é a seção mais reutilizável. Modelos comuns de rodapé:
FOOTER_JSON = '<footer>\nReturn a valid JSON object. No text outside JSON. No markdown code fences.\n</footer>'
FOOTER_MARKDOWN = '<footer>\nFormat your response as markdown.\nUse ## for section headers.\nUse bullet points for lists.\nMaximum 500 words.\n</footer>'
FOOTER_STRUCTURED = '<footer>\nRespond using this exact structure:\n1. Summary (1 sentence)\n2. Key Findings (bullet list)\n3. Recommendation (1 paragraph)\n</footer>'
print('Footer templates ready for reuse.')Injetando Conteúdo Dinâmico no Corpo
O corpo é a seção mais frequentemente criada de forma dinâmica durante a execução. Práticas recomendadas para a injeção dinâmica no corpo:
- Sempre envolva o conteúdo injetado em marcadores XML nomeados
- Higienize a entrada do usuário antes da injeção para evitar a injeção de instruções
- Trunque documentos muito longos e registre o truncamento no corpo
- Identifique claramente cada parte injetada (documento_1, consulta_do_usuário, histórico_da_conversa)
def safe_inject(user_content, max_chars=3000):
safe = user_content.replace('<', '<').replace('>', '>')
if len(safe) > max_chars:
safe = safe[:max_chars] + '... [TRUNCATED]'
return f'<user_input>\n{safe}\n</user_input>'
raw = 'User provided text here. Could be very long.'
print(safe_inject(raw))Estrutura Consistente em Toda a Base de Código
O verdadeiro poder do padrão Cabeçalho/Corpo/Rodapé surge quando toda a sua aplicação usa o mesmo padrão de forma consistente. Benefícios:
- Novos membros da equipe entendem qualquer instrução instantaneamente
- A revisão da instrução na revisão de código é mais fácil — os revisores sabem exatamente onde procurar
- Os testes automatizados podem validar cada seção de forma independente
- A migração de instruções entre modelos é direta — apenas o conteúdo muda, não a estrutura
Erros Comuns em Cabeçalho/Corpo/Rodapé
Erros que comprometem a eficácia do padrão:
- Instruções de formato no cabeçalho — ficam muito distantes da geração da resposta; o modelo as ignora parcialmente
- Descrição da tarefa oculta no corpo — o modelo pode tratá-la como dados a processar, não como uma instrução
- Restrições divididas entre as seções — são difíceis de auditar e levam a contradições
- Sem rodapé — a estrutura da saída se torna imprevisível à medida que a complexidade da instrução aumenta
Verificação Rápida
Onde as instruções de formato da saída devem ser colocadas no padrão Cabeçalho/Corpo/Rodapé, e por quê?
Cabeçalho/Corpo/Rodapé — Principais Conclusões
O padrão Cabeçalho/Corpo/Rodapé traz disciplina de estrutura de documentos à engenharia de instruções:
- Cabeçalho: Quem você é + a tarefa — define o enquadramento de tudo o que vem a seguir
- Corpo: Conteúdo e contexto — injetados dinamicamente e envolvidos em marcadores XML semânticos
- Rodapé: Instruções de formato e esquema da saída — colocados por último para exercer a máxima influência sobre a estrutura da saída
- O padrão se adapta naturalmente de instruções simples a instruções altamente complexas
- Os modelos de rodapé são reutilizáveis em instruções com o mesmo tipo de saída
- A consistência em toda a base de código torna as instruções fáceis de revisar, testar e manter
Aprenda AI Prompt Engineering com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 53
- Aulas
- 199
Perguntas Frequentes
A aula “Padrão de solicitação com cabeçalho, corpo e rodapé” é grátis?
Sim — o texto completo de “Padrão de solicitação com cabeçalho, corpo e rodapé” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.
O que vou aprender em “Padrão de solicitação com cabeçalho, corpo e rodapé”?
Estrutura consistente de solicitação que se adapta a solicitações complexas com várias tarefas. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Prompt Engineering?
Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Padrão de solicitação com cabeçalho, corpo e rodapé”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Prompt Engineering?
Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Usando tags XML como delimitadores
- Seções modulares de solicitações
- Padrão de solicitação com cabeçalho, corpo e rodapé
- Boas práticas de organização de solicitações