วิธีใช้พารามิเตอร์และเครื่องมือใหม่ของ GPT-5: คู่มือปฏิบัติ

การเปิดตัว GPT-5 ของ OpenAI นำมาซึ่งเป้าหมายที่คุ้นเคย นั่นคือ ความแม่นยำ ความเร็ว และการควบคุมของนักพัฒนาที่ดีขึ้น แต่ยังคงมาพร้อมกับชุดพารามิเตอร์ API และการผสานรวมเครื่องมือใหม่ๆ ที่เปลี่ยนแปลงวิธีที่ทีมต่างๆ ออกแบบพรอมต์ เรียกใช้โมเดล และเชื่อมโยงโมเดลเข้ากับรันไทม์ภายนอก บทความนี้จะอธิบายถึงการเปลี่ยนแปลงสำคัญๆ แสดงรูปแบบการใช้งานที่เป็นรูปธรรม และนำเสนอแนวทางปฏิบัติที่ดีที่สุดสำหรับการนำไปใช้อย่างปลอดภัยและคุ้มค่า

ฉันควรทราบเกี่ยวกับโมเดล พารามิเตอร์ และเครื่องมือ GPT-5 ใหม่ ๆ อะไรบ้าง?

GPT-5 คืออะไร?

ปัจจุบัน OpenAI เผยแพร่ GPT-5 ในรูปแบบต่างๆ เพื่อให้นักพัฒนาสามารถแลกเปลี่ยนความหน่วง ต้นทุน และความสามารถได้: gpt-5 (แบบจำลองการใช้เหตุผลเต็มรูปแบบ) gpt-5-mini (สมดุล) และ gpt-5-nano (ต้นทุนต่ำ ความหน่วงต่ำ) ขนาดเหล่านี้ช่วยให้คุณเลือกโมเดลที่เหมาะสมที่สุดสำหรับการสอบถามข้อมูลระยะสั้น การประมวลผลแบบแบตช์ หรืองานวิเคราะห์เชิงเหตุผลที่ซับซ้อน GPT-5 ใน ChatGPT นำเสนอเป็นระบบที่มีส่วนประกอบ "การคิด" และเวอร์ชัน API มุ่งเป้าไปที่โมเดลการวิเคราะห์เชิงเหตุผลโดยตรงสำหรับนักพัฒนา

พารามิเตอร์ API ใหม่ (ระดับสูง)

พารามิเตอร์ที่ปรากฏขึ้นมาไม่กี่ตัวที่เปลี่ยนวิธีการควบคุมเอาท์พุตและต้นทุนนั้นมีความโดดเด่นเป็นพิเศษ:

• พารามิเตอร์ใหม่: verbosity (ต่ำ/กลาง/สูง) เพื่อควบคุมความยาว/รูปร่างคำตอบ และ reasoning_effort (ตอนนี้: minimal, low, medium, high) เพื่อควบคุมว่าโมเดลจะคิดมากแค่ไหนก่อนที่จะตอบกลับ ใช้ minimal เมื่อคุณต้องการความเร็วเหนือความคิดที่ซับซ้อน
• โหมดขั้นต่ำ / โหมดการให้เหตุผล — ตัวเลือกในการเลือกคำตอบที่รวดเร็วและใช้เหตุผลที่น้อยกว่า (มีประโยชน์สำหรับการสืบค้นข้อเท็จจริงในระยะเวลาสั้นๆ) เทียบกับการใช้เหตุผลแบบขยาย ("การคิด") เมื่อต้องการลำดับความคิดที่ลึกซึ้งกว่า
• บริบทยาวและโทเค็น: GPT-5 รองรับบริบทขนาดใหญ่ (โทเค็นทั้งหมด ~400 รายการ: อินพุต ~272 รายการ + เอาต์พุต 128 รายการในเอกสาร) — ใช้สำหรับเอกสารขนาดใหญ่ ฐานโค้ด หรือการสนทนาที่ยาวนาน

พารามิเตอร์เหล่านี้ช่วยให้คุณปรับแต่งการแลกเปลี่ยนระหว่างคุณภาพ ความหน่วง และต้นทุนที่ระดับการโทรแทนที่จะเลือกเพียงขนาดโมเดลเท่านั้น

ประเภทเครื่องมือใหม่และการสนับสนุนโหลดดิบ

หนึ่งในสิ่งที่เพิ่มเข้ามาที่มีประโยชน์มากที่สุดของ GPT-5 คือสิ่งใหม่ custom ประเภทเครื่องมือ ที่ทำให้โมเดลสามารถส่งได้ เพย์โหลดข้อความดิบ เข้ากับรันไทม์เครื่องมือของคุณ (เช่น สคริปต์ Python, คำสั่ง SQL, คำสั่งเชลล์ หรือข้อความกำหนดค่าใดๆ ก็ได้) โดยไม่จำเป็นต้องเรียกใช้ฟังก์ชันที่ห่อหุ้มด้วย JSON วิธีนี้ช่วยลดความยุ่งยากเมื่อเชื่อมต่อโมเดลเข้ากับแซนด์บ็อกซ์ อินเทอร์พรีเตอร์ หรือฐานข้อมูล และช่วยให้สามารถใช้รูปแบบ "ซอฟต์แวร์ตามต้องการ" ได้อย่างครอบคลุมยิ่งขึ้น

การจำกัดผลลัพธ์: คุณสามารถบังคับใช้ไวยากรณ์/สัญญา (Context-Free Grammar, CFG) เพื่อให้เพย์โหลดของเครื่องมือมีความถูกต้องตามไวยากรณ์สำหรับรันไทม์ของคุณ การเรียกใช้เครื่องมือแบบคู่ขนาน + CFG ช่วยให้คุณสร้างเวิร์กโฟลว์เอเจนต์แบบหลายขั้นตอนโดยอัตโนมัติได้อย่างปลอดภัย

ฉันจะเรียกพารามิเตอร์และเครื่องมือใหม่ใน API ได้อย่างไร

(ใช้รูปแบบ Python SDK อย่างเป็นทางการ from openai import OpenAI และ API การตอบกลับตามเอกสาร)

1) ตั้งค่าความละเอียด + ความพยายามในการใช้เหตุผล

from openai import OpenAI
client = OpenAI(
    base_url="https://api.cometapi.com/v1/responses",
    api_key="<YOUR_CometAPI_KEY>",    
)

resp = client.responses.create(
    model="gpt-5",
    input="Summarize the following meeting notes in one short paragraph: ...",
    parameters={
        "verbosity": "low",            # low / medium / high

        "reasoning_effort": "minimal", # minimal / low / medium / high

        "max_output_tokens": 200
    }
)

print(resp.output_text)  # SDK convenience property aggregates returned text

คำตอบนี้จะสั้นและรวดเร็วเมื่อคุณต้องการความหน่วงและความกระชับ

2) เรียกใช้เครื่องมือที่กำหนดเองด้วยเนื้อหาข้อความดิบ (รูปแบบอิสระ)

# Example: send a raw SQL query (not JSON) to your "sql_runner" custom tool

from openai import OpenAI
client = OpenAI(
    base_url="https://api.cometapi.com/v1/responses",
    api_key="<YOUR_CometAPI_KEY>",    
)

resp = client.responses.create(
    model="gpt-5",
    input="Fetch the average order value for last month and return a SQL query only.",
    tools=[
        {
            "name": "sql_runner",
            "type": "custom",
            "description": "Executes raw SQL and returns results."
        }
    ],
    parameters={
        "verbosity": "medium"
    }
)

# The model can emit text that the tool receives directly (raw SQL)

# How your backend receives and executes the model->tool payload depends on your webhook/runtime.
print(resp.output_text)

ใช้ CFG หาก SQL ต้องปฏิบัติตามไวยากรณ์ที่เข้มงวดหรือรูปแบบที่อนุญาต (, )

3) ตัวอย่าง: ต้องใช้เอาต์พุตที่มีข้อจำกัดด้วย CFG

# Pseudocode / conceptual example for attaching a grammar to a tool call.

client.responses.create(
    model="gpt-5",
    input="Generate a safe shell command to list .txt files.",
    tools=[{
        "name":"shell_exec",
        "type":"custom",
        "description":"Runs a shell command in a sandbox",
        "grammar": "COMMAND -> 'ls' ' ' DIR_FILTER; DIR_FILTER -> '*.txt' | '-la *.txt'"
    }],
    parameters={"verbosity":"low"}
)

การขอ grammar/CFG รับประกันว่า GPT-5 จะส่งออกเฉพาะรูปแบบคำสั่งที่ได้รับอนุญาตที่ผู้รันเนอร์ของคุณยอมรับเท่านั้น

ฉันจะลงทะเบียนและใช้งานได้อย่างไร custom เครื่องมือในการส่งข้อมูลดิบ?

การขอ custom เครื่องมือถูกกำหนดไว้เมื่อคุณลงทะเบียนเครื่องมือในระบบของคุณ เครื่องมือได้รับข้อความธรรมดา (ไม่ใช่ JSON แบบมีโครงสร้าง) ดังนั้นรันไทม์ของคุณต้องพร้อมสำหรับการแยกวิเคราะห์และตรวจสอบความถูกต้อง

1. ลงทะเบียนเครื่องมือ (ฝั่งเซิร์ฟเวอร์; นิยามเทียม):

{
  "name": "code_executor",
  "type": "custom",
  "description": "Runs Python code in a sandbox and returns output or errors."
}

2. แบบจำลองเรียกใช้เครื่องมือ — ตัวอย่างคำสั่งผู้ช่วย (สิ่งที่โมเดลสร้างขึ้นเมื่อต้องการเรียกเครื่องมือ):

<tool name="code_executor">
print(run_tests_on_module('payment_processor'))
</tool>

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

การเปลี่ยนแปลงทางวิศวกรรมควรเกิดขึ้นอย่างไรด้วยตัวเลือกใหม่ของ GPT-5?

ฉันควรใช้ "การคิด" (การใช้เหตุผลขยายความ) แทนการตอบสนองขั้นต่ำเมื่อใด

ใช้โหมดการคิด/การใช้เหตุผลแบบขยายสำหรับงานที่ต้องใช้การอนุมานแบบขั้นตอน การวางแผนหลายขั้นตอน หรือการสร้างโค้ดที่ต้องคำนึงถึงข้อจำกัด สำรองโหมดการใช้เหตุผลแบบขั้นต่ำหรือ mini/nano สำหรับการสืบค้นข้อมูลแบบสั้น งานค้นหาข้อมูล และปริมาณงานกระจายข้อมูลจำนวนมาก (เช่น การให้คะแนนผู้สมัครจำนวนมาก) เมื่อความแม่นยำเป็นสิ่งสำคัญ (การเงิน กฎหมาย การวินิจฉัย) ควรใช้วิธีการให้เหตุผล/ค่าเริ่มต้นที่สูงกว่า gpt-5 และเพิ่มการตรวจสอบภายหลัง OpenAI ยังคงเน้นย้ำว่า GPT-5 ไม่ใช่ AGI — มันช่วยเพิ่มขีดความสามารถ แต่ไม่ใช่แหล่งข้อมูลที่ถูกต้องสมบูรณ์แบบ — ดังนั้นควรเลือกโหมดการให้เหตุผลให้เหมาะสม

แนวทางปฏิบัติดีที่สุดในการรวม GPT-5 เข้ากับรันไทม์และเครื่องมือภายนอกคืออะไร

ฉันควรออกแบบสถาปัตยกรรมรันไทม์ของเครื่องมืออย่างไร

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

การควบคุมความปลอดภัยมีอะไรบ้างที่จำเป็น?

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

เคล็ดลับปฏิบัติและแนวทางปฏิบัติที่ดีที่สุด

• เลือก verbosity ไม่รีบผ่าตัด ใช้ verbosity เพื่อปรับความยาว/ระดับรายละเอียดแทนการเขียนคำเตือนซ้ำๆ
• ใช้ reasoning_effort เพื่อการแลกเปลี่ยนระหว่างต้นทุน/เวลาแฝง ชุด minimal เพื่อการดึงข้อมูลข้อเท็จจริงหรือ UI อย่างรวดเร็ว high สำหรับงานการใช้เหตุผลที่ซับซ้อน
• ความปลอดภัยของเครื่องมือ: ตรวจสอบ/หลีกหนีข้อความดิบใดๆ ที่โมเดลส่งออกมาเสมอก่อนดำเนินการ ใช้ CFG และการทำความสะอาดฝั่งเซิร์ฟเวอร์เป็นแนวป้องกันชั้นที่สอง (คู่มือนี้เตือนเกี่ยวกับแนวปฏิบัติด้านความปลอดภัยของเครื่องมือ)
• การเรียกเครื่องมือแบบคู่ขนาน: คุณสามารถเรียกใช้เครื่องมือหลายรายการพร้อมกันได้เพื่อเพิ่มความเร็ว (เช่น การค้นหาเว็บ + การค้นหาฐานข้อมูล) จากนั้นให้แบบจำลองสังเคราะห์ผลลัพธ์ เหมาะสำหรับโฟลว์แบบเอเจนต์
• เอาท์พุตที่มีโครงสร้างเมื่อคุณต้องการ หากผู้บริโภคของคุณต้องการ JSON ให้ใช้ Structured Outputs / การรองรับ JSON Schema ใช้รูปแบบอิสระเฉพาะเมื่อข้อความดิบมีความเป็นธรรมชาติมากกว่าสำหรับรันไทม์เป้าหมาย
• การสตรีมและเอาท์พุตแบบยาว: ใช้การสตรีมเพื่อประมวลผลเอาท์พุตยาวๆ (โดยเฉพาะอย่างยิ่งกับงบโทเค็นขนาดใหญ่) ในระหว่างที่สร้าง

ฉันจะวัด ทดสอบ และเพิ่มประสิทธิภาพการทำงานและต้นทุนได้อย่างไร

ฉันควรติดตามเมตริกใดบ้าง?

• โทเค็นต่อคำขอ และ ราคาต่อการโทร (ใช้ขนาดโมเดล + ความละเอียดในการประมาณค่า)
• เวลาแฝง (หน้า 95/หน้า 99) และ อัตราความผิดพลาด — โดยเฉพาะสำหรับคำขอที่กระตุ้นให้มีการดำเนินการเครื่องมือภายนอก
• เมตริกคุณภาพ: อัตราความสำเร็จในการตรวจสอบอัตโนมัติ อัตราการตรวจสอบโดยมนุษย์ ความถี่ของอาการประสาทหลอนในการทดสอบทองคำ

วิธีการดำเนินการทดลอง

• ขนาดโมเดล A/B (gpt-5 vs gpt-5-mini) ในปริมาณงานตัวแทนเพื่อวัดความแม่นยำเทียบกับต้นทุน สำหรับปริมาณงานที่ต้องการคำตอบสั้นๆ จำนวนมาก mini or nano มักจะลดต้นทุนได้อย่างมากในขณะที่ยังคงความแม่นยำที่ยอมรับได้ การรายงานจากผู้จำหน่ายและสื่อต่างๆ เน้นย้ำถึงข้อแลกเปลี่ยนเหล่านี้ในเกณฑ์มาตรฐานเบื้องต้น ทดสอบงานสำคัญด้วยตัวคุณเอง

มีข้อจำกัดและข้อควรพิจารณาในการใช้อย่างรับผิดชอบอะไรบ้าง?

GPT-5 เป็น AGI หรือไม่ผิดพลาด?

OpenAI มองว่า GPT-5 เป็นการพัฒนาที่สำคัญในด้านการใช้งานและการใช้เหตุผล ไม่ใช่ AGI คาดว่าจะมีการพัฒนาความสามารถอย่างมีนัยสำคัญ (การเขียนโค้ด คณิตศาสตร์ การใช้เหตุผลแบบหลายขั้นตอน) แต่ก็อาจมีข้อผิดพลาดและภาพหลอนเกิดขึ้นเป็นครั้งคราว วางแผนเวิร์กโฟลว์ของผลิตภัณฑ์ที่ตรวจสอบความถูกต้องของผลลัพธ์ของแบบจำลองก่อนดำเนินการอัตโนมัติในโดเมนที่ละเอียดอ่อน

การปฏิบัติตามกฎระเบียบ ความเป็นส่วนตัว และการกำกับดูแลข้อมูล

• ปฏิบัติต่อคำเตือนและเอาท์พุตของโมเดลเป็นสิ่งละเอียดอ่อน: ปิดบัง PII ก่อนที่จะส่งไปยัง API หากนโยบายของคุณห้ามไม่ให้ส่งข้อมูลดังกล่าว
• ทำความเข้าใจนโยบายการเก็บรักษาและการใช้งานในข้อกำหนดของ OpenAI สำหรับบัญชี/ภูมิภาคของคุณ ใช้สัญญาองค์กรเพื่อการปกป้องข้อมูลที่เข้มงวดยิ่งขึ้นหากจำเป็น
• จัดทำเอกสารและเปิดเผยบทบาทของโมเดลให้กับผู้ใช้ปลายทางทราบในกรณีที่การตัดสินใจมีผลกระทบต่อพวกเขาอย่างมาก (ข้อกำหนดด้านความโปร่งใสในเขตอำนาจศาลหลายแห่ง)

รายการตรวจสอบด่วนและรูปแบบโค้ดเพื่อเริ่มต้นใช้งาน

รายการตรวจสอบก่อนการเปิดตัว

1. เลือกโมเดลเป้าหมาย (ความแม่นยำเทียบกับต้นทุน): gpt-5, gpt-5-miniหรือ gpt-5-nano.
2. กำหนด verbosity ค่าเริ่มต้นสำหรับจุดสิ้นสุดแต่ละจุด (เช่น จุดสิ้นสุด API ที่ขับเคลื่อนการค้นหาด่วนเทียบกับการวิเคราะห์เชิงลึก)
3. ลงทะเบียนและแข็งตัว custom รันไทม์ของเครื่องมือ (แซนด์บ็อกซ์ ตัวตรวจสอบ บันทึก)
4. เพิ่มขั้นตอนการตรวจยืนยันอัตโนมัติสำหรับเอาท์พุตเครื่องมือใดๆ ที่ดำเนินการบนระบบของคุณ
5. สร้างแดชบอร์ดการตรวจสอบสำหรับโทเค็น ความหน่วง และเมตริกคุณภาพโมเดล

ตัวอย่างรูปแบบการประสานเสียง (pseudocode)

1. คำขอของผู้ใช้ → เลือกโมเดลและความละเอียด (ตรรกะการกำหนดเส้นทาง)
2. พรอมต์ระบบจะกำหนดรูปแบบเครื่องมือ + โหมดการให้เหตุผล
3. ส่งคำขอเสร็จสิ้นการแชท
4. หากผู้ช่วยเรียกใช้ custom เครื่องมือ: ตรวจสอบโหลด → ดำเนินการในแซนด์บ็อกซ์ → ส่งผลลัพธ์กลับไปยังผู้ช่วย → ผู้ช่วยสรุปการตอบสนอง
5. หากการดำเนินงานมีความเสี่ยงสูง: ต้องได้รับการอนุมัติจากมนุษย์

ใช้ GPT-5 ใน CometAPI

CometAPI เป็นแพลตฟอร์ม API แบบรวมที่รวบรวมโมเดล AI มากกว่า 500 โมเดลจากผู้ให้บริการชั้นนำ เช่น ซีรีส์ GPT ของ OpenAI, Gemini ของ Google, Claude ของ Anthropic, Midjourney, Suno และอื่นๆ ไว้ในอินเทอร์เฟซเดียวที่เป็นมิตรกับนักพัฒนา ด้วยการนำเสนอการตรวจสอบสิทธิ์ การจัดรูปแบบคำขอ และการจัดการการตอบสนองที่สอดคล้องกัน CometAPI จึงทำให้การรวมความสามารถของ AI เข้ากับแอปพลิเคชันของคุณง่ายขึ้นอย่างมาก ไม่ว่าคุณจะกำลังสร้างแชทบ็อต เครื่องกำเนิดภาพ นักแต่งเพลง หรือไพพ์ไลน์การวิเคราะห์ที่ขับเคลื่อนด้วยข้อมูล CometAPI ช่วยให้คุณทำซ้ำได้เร็วขึ้น ควบคุมต้นทุน และไม่ขึ้นอยู่กับผู้จำหน่าย ทั้งหมดนี้ในขณะที่ใช้ประโยชน์จากความก้าวหน้าล่าสุดในระบบนิเวศ AI

หากต้องการข้อมูลอ้างอิงที่ชัดเจน โปรดดูรายการ Cookbook ของ OpenAI เกี่ยวกับพารามิเตอร์และเครื่องมือ GPT-5 ซึ่งเป็นแหล่งข้อมูลหลักสำหรับฟิลด์ API การลงทะเบียนเครื่องมือ และรูปแบบการใช้งาน

ความคิดสุดท้าย

การรวมขนาดโมเดลของ GPT-5 พารามิเตอร์ใหม่ เช่น verbosityและ custom การรองรับเพย์โหลดดิบของเครื่องมือสร้างตัวเลือกใหม่ที่ทรงพลังสำหรับทีมผลิตภัณฑ์ ตั้งแต่งานให้คะแนนขนาดใหญ่ที่มีต้นทุนต่ำ ไปจนถึงเวิร์กโฟลว์ "ซอฟต์แวร์ตามสั่ง" ที่โมเดลสร้างโค้ดหรือ SQL ที่รันไทม์ที่ปลอดภัยของคุณดำเนินการ ข้อดีข้อเสียที่คุ้นเคยกันดีคือ ความสามารถเทียบกับต้นทุน ความเร็วเทียบกับความลึก และการทำงานอัตโนมัติเทียบกับการควบคุมดูแลโดยมนุษย์ เริ่มต้นจากสิ่งเล็กๆ (เลือกกรณีการใช้งานการค้นพบเพียงกรณีเดียว) ใช้เครื่องมืออย่างหนัก และทำซ้ำ — ออกแบบรันไทม์และพรอมต์ของเครื่องมือของคุณเพื่อให้ผลลัพธ์ของโมเดลเป็นไปตามที่ต้องการ ที่ตรวจสอบได้ ก่อนที่จะกลายเป็นการกระทำ

นักพัฒนาสามารถเข้าถึงได้ จีพีที-5 GPT-5 Nano และ GPT-5 Mini ผ่าน CometAPI รุ่นล่าสุดที่ระบุไว้เป็นข้อมูล ณ วันที่เผยแพร่บทความ เริ่มต้นด้วยการสำรวจความสามารถของโมเดลใน สนามเด็กเล่น และปรึกษา คู่มือ API สำหรับคำแนะนำโดยละเอียด ก่อนเข้าใช้งาน โปรดตรวจสอบให้แน่ใจว่าคุณได้เข้าสู่ระบบ CometAPI และได้รับรหัส API แล้ว โคเมทเอพีไอ เสนอราคาที่ต่ำกว่าราคาอย่างเป็นทางการมากเพื่อช่วยคุณบูรณาการ

คุณสามารถใช้ API gpt-5 ของ Cpmr เพื่อทดลองกับพารามิเตอร์ใหม่ๆ ได้ เพียงแทนที่คีย์ openAI ด้วยคีย์ CometAPI คุณสามารถใช้ API gpt-5 ของ CometAPI เพื่อทดลองกับพารามิเตอร์ใหม่ๆ ได้ เพียงแทนที่คีย์ openAI ด้วยคีย์ CometAPI มีสองทางเลือก: รูปแบบการเรียกใช้ฟังก์ชันการแชท และ รูปแบบการเรียกฟังก์ชันการตอบสนอง

การส่ง CoT มีอยู่เฉพาะใน Responses API เท่านั้น ซึ่งจะช่วยปรับปรุงความชาญฉลาด ลดจำนวนโทเค็นอนุมานที่สร้างขึ้น ปรับปรุงอัตราการเข้าถึงแคช และลดเวลาแฝง พารามิเตอร์อื่นๆ ส่วนใหญ่ยังคงเหมือนเดิม แต่รูปแบบจะแตกต่างกัน ดังนั้นเราจึงแนะนำให้ใช้ คำตอบ รูปแบบการเข้าถึง gpt-5 ใน CometAPI