AI Prompt Engineering · บทเรียน

รูปแบบพรอมป์ตส่วนหัว-เนื้อหา-ส่วนท้าย

โครงสร้างพรอมป์ตที่สม่ำเสมอและขยายไปสู่งานหลายขั้นตอนที่ซับซ้อนได้

บทเรียน 3 จาก 413 ขั้นตอน

รูปแบบพรอมป์ตส่วนหัว-เนื้อหา-ส่วนท้าย เป็นบทเรียน AI Prompt Engineering ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Prompt Engineering และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน

Prompt ในรูปแบบเอกสาร

เอกสารแบบยาว — รายงาน บทความ อีเมล — ใช้โครงสร้างส่วนหัว/เนื้อหา/ส่วนท้าย เพราะช่วยให้ทำความเข้าใจและนำทางได้ง่าย ผู้อ่านทราบว่าควรคาดหวังอะไรในแต่ละส่วน

หลักการเดียวกันนี้ใช้กับ Prompt เมื่อ Prompt ยาวเกินกว่าสองสามประโยค โครงสร้างส่วนหัว/เนื้อหา/ส่วนท้ายจะช่วยให้สแกนอ่าน ดูแลรักษา และใช้งานได้อย่างสม่ำเสมอ

รูปแบบนี้ใช้ได้กับโมเดลต่าง ๆ และขยายจาก Prompt แบบง่ายไปจนถึง Prompt ที่ซับซ้อนมากได้

ส่วนหัว

ส่วนหัวตอบคำถามสองข้อ ได้แก่ คุณคือใคร และ งานคืออะไร

ส่วนนี้กำหนดอัตลักษณ์ของโมเดล (บุคลิกหรือตำแหน่งบทบาท) และระบุเป้าหมายหลักของ Prompt ทุกสิ่งที่เหลือจะต่อยอดจากรากฐานนี้

ส่วนหัวที่ดีควรกระชับ โดยทั่วไปมีความยาว 2-4 ประโยค และไม่รวมตัวอย่าง ข้อจำกัด หรือกฎของผลลัพธ์

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)

ส่วนเนื้อหา

ส่วนเนื้อหาประกอบด้วยเนื้อหาหรือบริบทที่โมเดลต้องใช้เพื่อทำงานให้สำเร็จ นี่คือพื้นที่ข้อมูลหลัก:

เอกสารต้นฉบับที่จะประมวลผล
ประวัติการสนทนา
ข้อมูลที่มีโครงสร้าง (ส่วนย่อยของ JSON, CSV)
เอกสารอ้างอิง
ข้อมูลนำเข้าจริงของผู้ใช้

ส่วนเนื้อหาเป็นส่วนที่ใหญ่ที่สุด และมักถูกแทรกแบบไดนามิกขณะทำงาน

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

ส่วนท้าย

ส่วนท้ายประกอบด้วยคำสั่งเกี่ยวกับรูปแบบและโครงร่างผลลัพธ์ โดยอยู่เป็นส่วนสุดท้ายเนื่องจาก:

โมเดลอ่านจากบนลงล่างและใช้กฎการจัดรูปแบบกับสิ่งที่เพิ่งประมวลผล
คำสั่งเกี่ยวกับรูปแบบที่อยู่ใกล้ส่วนท้ายมีโอกาสถูกละเลยน้อยกว่า
ส่วนท้ายมักนำกลับมาใช้ซ้ำได้กับ Prompt ที่มีประเภทผลลัพธ์เดียวกัน

ส่วนท้ายควรระบุไว้อย่างชัดเจนว่า ส่งคืนออบเจ็กต์ JSON ที่มีฟิลด์เหล่านี้ ไม่ใช่ จัดรูปแบบให้สวยงาม

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)

การประกอบรูปแบบฉบับสมบูรณ์

การรวมส่วนหัว ส่วนเนื้อหา และส่วนท้ายเข้าด้วยกันเป็นฟังก์ชัน Prompt ที่สมบูรณ์และนำกลับมาใช้ซ้ำได้:

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

เหตุใดลำดับนี้จึงได้ผล

ลำดับส่วนหัว/เนื้อหา/ส่วนท้ายสอดคล้องกับวิธีที่โมเดลประมวลผลบริบท:

ส่วนหัวก่อน — กำหนดอัตลักษณ์และเป้าหมาย เพื่อเตรียมโมเดลให้พร้อมสำหรับสิ่งที่จะตามมา
ส่วนเนื้อหาถัดมา — โมเดลจึงประมวลผลเนื้อหาผ่านมุมมองของบทบาทและงานที่กำหนดไว้แล้ว
ส่วนท้ายเป็นลำดับสุดท้าย — คำสั่งเกี่ยวกับรูปแบบอยู่ก่อนที่โมเดลจะสร้างคำตอบทันที จึงเพิ่มอิทธิพลต่อโครงสร้างผลลัพธ์ได้สูงสุด

การวางคำสั่งเกี่ยวกับรูปแบบไว้ในส่วนหัว (ตอนต้น) ทำให้โมเดลลืมคำสั่งเหล่านี้ไปบางส่วนเมื่อถึงเวลาที่ต้องเขียนคำตอบ

การขยายไปสู่พรอมต์ที่ซับซ้อน

รูปแบบส่วนหัว/เนื้อหา/ส่วนท้ายสามารถขยายรองรับพรอมต์ที่ซับซ้อนได้อย่างเป็นธรรมชาติ:

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

การนำแม่แบบส่วนท้ายกลับมาใช้ใหม่

เนื่องจากส่วนท้ายเป็นตัวกำหนดโครงสร้างผลลัพธ์ จึงเป็นส่วนที่นำกลับมาใช้ใหม่ได้มากที่สุด แม่แบบส่วนท้ายที่ใช้กันทั่วไปมีดังนี้:

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

การแทรกเนื้อหาแบบไดนามิกในส่วนเนื้อหา

เนื้อหาเป็นส่วนที่มักสร้างขึ้นแบบไดนามิกขณะรันไทม์มากที่สุด แนวทางปฏิบัติที่ดีที่สุดสำหรับการแทรกเนื้อหาแบบไดนามิกมีดังนี้:

ครอบเนื้อหาที่แทรกเข้ามาด้วยแท็ก XML ที่มีชื่อกำกับเสมอ
ทำให้ข้อมูลป้อนเข้าของผู้ใช้ปลอดภัยก่อนแทรก เพื่อป้องกันการแทรกคำสั่งในพรอมต์
ตัดทอนเอกสารที่ยาวมาก และระบุการตัดทอนไว้ในส่วนเนื้อหา
ระบุป้ายกำกับของแต่ละส่วนที่แทรกเข้ามาให้ชัดเจน (เอกสาร_1, คำค้นหาของผู้ใช้, ประวัติการสนทนา)

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

โครงสร้างที่สอดคล้องกันทั่วทั้งฐานรหัส

พลังที่แท้จริงของรูปแบบส่วนหัว/เนื้อหา/ส่วนท้ายจะแสดงออกมาเมื่อแอปพลิเคชันทั้งหมดใช้รูปแบบเดียวกันอย่างสม่ำเสมอ ประโยชน์ที่ได้รับมีดังนี้:

สมาชิกใหม่ในทีมเข้าใจพรอมต์ใด ๆ ได้ทันที
การตรวจทานพรอมต์ในการตรวจทานรหัสทำได้ง่ายขึ้น — ผู้ตรวจทานทราบแน่ชัดว่าควรดูที่ใด
การทดสอบอัตโนมัติสามารถตรวจสอบแต่ละส่วนแยกจากกันได้
การย้ายพรอมต์ระหว่างโมเดลทำได้ตรงไปตรงมา — เปลี่ยนเฉพาะเนื้อหา ไม่เปลี่ยนโครงสร้าง

ข้อผิดพลาดที่พบบ่อยในส่วนหัว/เนื้อหา/ส่วนท้าย

ข้อผิดพลาดที่ทำให้รูปแบบนี้สูญเสียประสิทธิภาพ:

คำสั่งกำหนดรูปแบบอยู่ในส่วนหัว — อยู่ห่างจากการสร้างผลลัพธ์เกินไป โมเดลจึงเพิกเฉยต่อคำสั่งบางส่วน
คำอธิบายงานถูกซ่อนอยู่ในส่วนเนื้อหา — โมเดลอาจมองว่าเป็นข้อมูลที่ต้องประมวลผล ไม่ใช่คำสั่ง
ข้อจำกัดถูกแบ่งไว้ในหลายส่วน — ตรวจสอบได้ยากและนำไปสู่ความขัดแย้ง
ไม่มีส่วนท้าย — โครงสร้างผลลัพธ์จะคาดเดาไม่ได้มากขึ้นเมื่อพรอมต์ซับซ้อนขึ้น

ตรวจสอบอย่างรวดเร็ว

ในรูปแบบส่วนหัว/เนื้อหา/ส่วนท้าย ควรวางคำสั่งกำหนดรูปแบบผลลัพธ์ไว้ที่ใด และเพราะเหตุใด

ตอบคำถามในบทเรียนแบบโต้ตอบ

ส่วนหัว/เนื้อหา/ส่วนท้าย — ประเด็นสำคัญ

รูปแบบส่วนหัว/เนื้อหาส่วนท้ายนำหลักวินัยด้านโครงสร้างเอกสารมาใช้กับวิศวกรรมพรอมต์:

ส่วนหัว: คุณคือใคร + งาน — กำหนดกรอบให้กับทุกสิ่งที่จะตามมา
ส่วนเนื้อหา: เนื้อหาและบริบท — แทรกแบบไดนามิกและครอบด้วยแท็ก XML เชิงความหมาย
ส่วนท้าย: คำสั่งกำหนดรูปแบบและโครงสร้างผลลัพธ์ — วางไว้ท้ายสุดเพื่อให้มีอิทธิพลต่อโครงสร้างผลลัพธ์มากที่สุด
รูปแบบนี้ขยายจากพรอมต์แบบง่ายไปสู่พรอมต์ที่ซับซ้อนมากได้อย่างเป็นธรรมชาติ
แม่แบบส่วนท้ายสามารถนำกลับมาใช้กับพรอมต์ที่มีประเภทผลลัพธ์เดียวกันได้
ความสอดคล้องกันทั่วทั้งฐานรหัสทำให้พรอมต์ตรวจทาน ทดสอบ และบำรุงรักษาได้ง่าย

เริ่มต้นได้ฟรี

เรียนรู้ AI Prompt Engineering ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 53
บทเรียน: 199

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “รูปแบบพรอมป์ตส่วนหัว-เนื้อหา-ส่วนท้าย” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รูปแบบพรอมป์ตส่วนหัว-เนื้อหา-ส่วนท้าย” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Prompt Engineering ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบพรอมป์ตส่วนหัว-เนื้อหา-ส่วนท้าย”

โครงสร้างพรอมป์ตที่สม่ำเสมอและขยายไปสู่งานหลายขั้นตอนที่ซับซ้อนได้ คุณปฏิบัติ AI Prompt Engineering ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Prompt Engineering หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Prompt Engineering บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “รูปแบบพรอมป์ตส่วนหัว-เนื้อหา-ส่วนท้าย” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน AI Prompt Engineering นี้ได้ไหม

ได้ บทเรียน AI Prompt Engineering ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การใช้แท็ก XML เป็นตัวแบ่งส่วน
ส่วนประกอบพรอมป์ตแบบโมดูลาร์
รูปแบบพรอมป์ตส่วนหัว-เนื้อหา-ส่วนท้าย
แนวทางปฏิบัติที่ดีในการจัดระเบียบพรอมป์ต

← กลับไปที่ AI Prompt Engineering