0Pricing
AI Prompt Engineering · Leçon

Modèle d’invite en-tête-corps-pied de page

Adoptez une structure d’invite cohérente qui s’adapte aux tâches complexes et multiples.

Modèle d’invite en-tête-corps-pied de page est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Les prompts comme documents

Les documents longs — rapports, articles, courriels — utilisent une structure En-tête/Corps/Pied de page, car elle est facile à parcourir mentalement. Les lecteurs savent à quoi s’attendre dans chaque zone.

Le même principe s’applique aux prompts. Lorsque les prompts dépassent quelques phrases, une structure En-tête/Corps/Pied de page les rend faciles à parcourir, faciles à maintenir et cohérents.

Cette structure fonctionne avec tous les modèles et s’adapte aux prompts simples comme aux prompts très complexes.

La section En-tête

L’En-tête répond à deux questions : Qui êtes-vous ? et Quelle est la tâche ?

Il définit l’identité du modèle (persona ou rôle) et énonce l’objectif principal du prompt. Tout le reste s’appuie sur cette base.

Un en-tête efficace est concis — généralement 2 à 4 phrases. Il ne contient ni exemples, ni contraintes, ni règles de sortie.

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)

La section Corps

Le Corps contient le contenu ou le contexte dont le modèle a besoin pour effectuer la tâche. Il s’agit de la principale zone de données :

  • Documents sources à traiter
  • Historique de la conversation
  • Données structurées (extraits JSON, CSV)
  • Documents de référence
  • Entrée réelle de l’utilisateur

Le corps est la section la plus grande et celle qui est le plus souvent injectée dynamiquement à l’exécution.

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))

La section Pied de page

Le Pied de page contient les instructions de formatage et le schéma de sortie. Il apparaît en dernier, car :

  • Le modèle lit de haut en bas et applique les règles de formatage à ce qu’il vient de traiter
  • Les instructions de formatage proches de la fin sont moins susceptibles d’être ignorées
  • Le pied de page est souvent réutilisable dans les prompts ayant le même type de sortie

Le pied de page doit être explicite : Renvoyez un objet JSON contenant ces champs, et non mettez-le joliment en forme.

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)

Assembler la structure complète

Combinaison de l’En-tête, du Corps et du Pied de page dans une fonction de prompt complète et réutilisable :

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))

Pourquoi cet ordre fonctionne

L’ordre En-tête/Corps/Pied de page reflète la façon dont les modèles traitent le contexte :

  1. En-tête en premier — établit l’identité et l’objectif, préparant le modèle à ce qui suit
  2. Corps en deuxième — le modèle traite alors le contenu à travers le rôle et la tâche établis
  3. Pied de page en dernier — les instructions de formatage arrivent juste avant que le modèle ne génère sa réponse, ce qui maximise leur influence sur la structure de sortie

Placer les instructions de formatage dans l’en-tête (en premier) les fait partiellement oublier au modèle au moment où il rédige sa réponse.

Passer à des invites complexes

Le modèle En-tête/Corps/Pied de page s’adapte naturellement lorsque les invites deviennent complexes :

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])

Réutiliser des modèles de pied de page

Comme le pied de page définit la structure de sortie, c’est la section la plus réutilisable. Modèles de pied de page courants :

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.')

Injecter du contenu dynamique dans le corps

Le corps est la section qui est le plus souvent construite dynamiquement lors de l’exécution. Bonnes pratiques pour l’injection de contenu dynamique :

  • Entourez toujours le contenu injecté de balises XML nommées
  • Assainissez les données saisies par l’utilisateur avant l’injection afin d’empêcher l’injection d’invites
  • Tronquez les documents très longs et signalez la troncature dans le corps
  • Étiquetez clairement chaque élément injecté (document_1, requête_utilisateur, historique_discussion)
def safe_inject(user_content, max_chars=3000):
    safe = user_content.replace('<', '&lt;').replace('>', '&gt;')
    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))

Structure cohérente dans toute la base de code

La véritable puissance du modèle En-tête/Corps/Pied de page apparaît lorsque toute votre application utilise systématiquement la même structure. Avantages :

  • Les nouveaux membres de l’équipe comprennent instantanément n’importe quelle invite
  • La revue des invites dans le cadre d’une revue de code est plus facile — les réviseurs savent exactement où regarder
  • Les tests automatisés peuvent valider chaque section indépendamment
  • La migration des invites entre les modèles est simple — seul le contenu change, pas la structure

Erreurs courantes dans En-tête/Corps/Pied de page

Erreurs qui nuisent à l’efficacité du modèle :

  • Instructions de format dans l’en-tête — trop éloignées de la génération de la réponse ; le modèle les ignore partiellement
  • Description de la tâche enfouie dans le corps — le modèle peut la traiter comme des données à traiter plutôt que comme une directive
  • Contraintes réparties entre plusieurs sections — difficiles à vérifier, elles entraînent des contradictions
  • Absence de pied de page — la structure de sortie devient imprévisible à mesure que l’invite gagne en complexité

Vérification rapide

Où faut-il placer les instructions relatives au format de sortie dans le modèle En-tête/Corps/Pied de page, et pourquoi ?

En-tête/Corps/Pied de page — Points clés

Le modèle En-tête/Corps/Pied de page apporte la discipline de structuration des documents à l’ingénierie des invites :

  • En-tête : qui vous êtes et la tâche — définit le cadre de tout ce qui suit
  • Corps : contenu et contexte — injectés dynamiquement et entourés de balises XML sémantiques
  • Pied de page : instructions de format et schéma de sortie — placé en dernier pour exercer une influence maximale sur la structure de sortie
  • Le modèle s’adapte naturellement des invites simples aux invites très complexes
  • Les modèles de pied de page sont réutilisables entre les invites ayant le même type de sortie
  • La cohérence dans toute votre base de code rend les invites faciles à relire, tester et maintenir

Questions Fréquemment Posées

La leçon « Modèle d’invite en-tête-corps-pied de page » est-elle gratuite ?

Oui — le texte complet de « Modèle d’invite en-tête-corps-pied de page » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèle d’invite en-tête-corps-pied de page » ?

Adoptez une structure d’invite cohérente qui s’adapte aux tâches complexes et multiples. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Modèle d’invite en-tête-corps-pied de page » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Utiliser des balises XML comme délimiteurs
  2. Sections d’invite modulaires
  3. Modèle d’invite en-tête-corps-pied de page
  4. Bonnes pratiques d’organisation des invites
← Retour à AI Prompt Engineering