TL;DR
Muse Wonder คือโมเดลพรีวิวของ Meta สำหรับงานโค้ดดิ้งซับซ้อน การให้เหตุผล และเวิร์กโฟลว์แบบเอเจนต์ นักพัฒนาสามารถเข้าถึง Muse Wonder API ใน CometAPI ด้วยไคลเอนต์ที่เข้ากันได้กับ OpenAI และตั้งค่า model="muse-wonder" คู่มือนี้ช่วยให้นักพัฒนาที่คุ้นเคยกับ Python หรือ JavaScript ส่งคำขอแรก เพิ่มการสตรีม และประเมินด้านการให้เหตุผล สื่อ และต้นทุน เมื่อเทียบกับ Muse Spark เหตุผลเชิงปฏิบัติในการประเมิน Wonder คือศักยภาพในการทำงานยากให้สำเร็จได้อย่างน่าเชื่อถือยิ่งขึ้น; การมีหน้าต่างบริบทขนาดใหญ่อย่างเดียวไม่ใช่เหตุผลที่จะย้าย
Key Takeaways
- การผสานรวม: ใช้คีย์ API ฝั่งแบ็กเอนด์,
https://api.cometapi.com/v1, และ model="muse-wonder" - ศักยภาพ: Muse Wonder มีหน้าต่างบริบท 1,048,576 โทเค็น; ตัดบริบทซ้ำเพื่อตรวจคุมต้นทุน
- ความสามารถ: ประเมินการสตรีม การเรียกใช้เครื่องมือ และสื่อ แยกกันบนเส้นทางเกตเวย์ที่เลือก
- การให้เหตุผล: Muse Wonder เนทีฟรองรับตั้งแต่ minimal ถึง max; ความพยายามสูงขึ้นเพิ่มการใช้โทเค็นและความหน่วง
- การปรับใช้: วัดผลงานจริง ตรวจสอบการเรียกเก็บเงินปัจจุบัน และเก็บโมเดลสำหรับย้อนกลับก่อนขยายทราฟฟิก
What Is Muse Wonder API?
Meta เปิดตัว Muse Wonder เมื่อวันที่ 12 ตุลาคม 2026 โมเดลนี้เปิดให้ใช้งานพรีวิวผ่าน Meta Model API สำหรับงานโค้ดดิ้ง การให้เหตุผล และเวิร์กโฟลว์ที่ขับเคลื่อนด้วยเครื่องมือ CometAPI ใช้ตัวระบุโมเดล muse-wonder; ตัวระบุเนทีฟของ Meta คือ muse-wonder-1.0
โมเดลเนทีฟมุ่งเน้นการให้เหตุผลระยะยาว งานโค้ดดิ้ง และงานที่ขับเคลื่อนด้วยเครื่องมือ แอปพลิเคชันยังต้องจัดเตรียมเครื่องมือ สถานะถาวร เงื่อนไขการหยุด และการตรวจสอบสิทธิ์ด้วยตนเอง; การเรียกโมเดลหนึ่งครั้งไม่ได้สร้างสภาพแวดล้อมการทำงานอัตโนมัติ
Muse Wonder API specifications
| Specification | Meta model documentation |
|---|---|
| Developer | Meta |
| Release | October 12, 2026 |
| Native Meta identifier | muse-wonder-1.0 |
| CometAPI identifier | muse-wonder |
| Native context window | 1,048,576 tokens |
| Native inputs | Text, image, video, audio and PDF; gateway formats require separate validation |
| Output | Text |
| Native API status | Preview |
| Streaming and tools | Native API capabilities; validate the selected CometAPI route |
| Full variant | Eligible Muse Code subscriptions; not selected by reasoning effort |
Muse Wonder vs Muse Wonder Full
Muse Wonder ใช้ได้ผ่าน Meta Model API; Muse Wonder Full ใช้ได้เฉพาะผ่านการสมัครใช้งาน Power Usage และ Maximum Usage ใน Muse Code และการตั้งค่า reasoning_effort เป็น max จะไม่สลับไปเป็น Muse Wonder Full ดู ประกาศเปิดตัวของ Meta
Muse Spark API vs Muse Wonder API
เลือกโมเดลโดยอิงผลสำเร็จของงานที่วัดได้และต้นทุน คู่มือเนทีฟแนะนำ Wonder สำหรับงานซับซ้อน และ Spark สำหรับเวิร์กโหลดที่สำคัญด้านต้นทุน; ทั้งคู่มีหน้าต่างบริบท 1,048,576 โทเค็น เปรียบเทียบเวอร์ชัน Spark ที่เฉพาะเจาะจง แทนที่จะสมมุติว่าเวอร์ชันทั้งหมดมีความสามารถเหมือนกัน
Muse Spark เหมาะกับเวิร์กโหลดที่เน้นประหยัดต้นทุน; Muse Wonder มุ่งเป้าไปที่งานโค้ดดิ้งซับซ้อนและการให้เหตุผลแบบต่อเนื่อง ตรวจสอบการรองรับสื่อ การควบคุมด้าน reasoning และการเรียกเก็บเงินสำหรับเวอร์ชันโมเดลและเส้นทางเกตเวย์ที่ใช้จริง เก็บโมเดลที่ตรงตามเป้าหมายความสำเร็จของงานและต้นทุนที่คุณกำหนด
How to Use Muse Wonder API with CometAPI Step by Step
Step 1: Create and secure your CometAPI key
สร้างบัญชี สร้างคีย์ API ฝั่งแบ็กเอนด์ และอย่าฝังคีย์ไว้ในโค้ดฝั่งเบราว์เซอร์หรือคลังสาธารณะ ปฏิบัติตาม เอกสารการผสานรวม CometAPI สำหรับการยืนยันสิทธิ์ ตัวอย่างเหล่านี้ต้องใช้บัญชีที่มีเงินหรือมีสิทธิ์, Python 3.10+ หรือสภาพแวดล้อม Node.js LTS ที่รองรับ และการเข้าถึง HTTPS ขาออก บันทึกตัวอย่าง JavaScript เป็นไฟล์ .mjs
ตั้งค่า API key ในเซสชัน Bash
export COMETAPI_KEY="your_cometapi_api_key"
ตั้งค่า API key ในเซสชัน PowerShell
$env:COMETAPI_KEY="your_cometapi_api_key"
Step 2: Configure the Muse Wonder endpoint
| Setting | Value |
|---|---|
| Base URL | https://api.cometapi.com/v1 |
| Chat endpoint | /chat/completions |
| HTTP method | POST |
| Authorization | Bearer API key |
| Model | muse-wonder |
Step 3: Send your first request with cURL
ส่งคำขอแชทแบบยืนยันตัวตนขั้นต่ำ
curl -X POST "https://api.cometapi.com/v1/chat/completions" \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "muse-wonder",
"messages": [
{"role": "system", "content": "You are a senior engineer."},
{"role": "user", "content": "List three ways to improve Python API reliability."}
],
"stream": false
}'
คำขอแบบไม่สตรีมที่สำเร็จควรส่งคืน choices[0].message.content ตรวจสอบ model และ usage ที่ส่งกลับมาเมื่อมีให้ และยืนยันว่าข้อความตอบตรงกับพรอมป์ตของคุณ ความล้มเหลวด้านการยืนยันสิทธิ์ต้องตรวจสอบข้อมูลรับรอง; ข้อผิดพลาดโมเดลไม่ถูกต้องต้องตรวจสอบการเข้าถึงโมเดล ตัวอย่างมีไว้เพื่อแสดงรูปแบบคำขอและไม่ได้แทนค่าความหน่วงหรือผลการเบนช์มาร์กที่วัดได้
Step 4: Make a Python request
ติดตั้งไลบรารีไคลเอนต์ Python
pip install --upgrade openai
ส่งคำขอ Python และตรวจสอบการใช้โทเค็น
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
timeout=120.0,
)
response = client.chat.completions.create(
model="muse-wonder",
messages=[
{"role": "system", "content": "You are a Python engineer."},
{"role": "user", "content": "Review: def divide(a,b): return a/b"},
],
)
print(response.choices[0].message.content)
if response.usage:
print("Total tokens:", response.usage.total_tokens)
Step 5: Use JavaScript or Node.js
ติดตั้งไลบรารีไคลเอนต์ JavaScript
npm install openai
ส่งคำขอ Node.js
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.COMETAPI_KEY,
baseURL: "https://api.cometapi.com/v1",
});
const response = await client.chat.completions.create({
model: "muse-wonder",
messages: [{role: "user", content: "Explain async/await."}],
});
console.log(response.choices[0].message.content);
How to Stream Muse Wonder Responses with CometAPI
การสตรีมจะส่งคืนชิ้นส่วนคำตอบแบบเพิ่มขึ้นผ่าน Server-Sent Events ช่วยให้การตอบสนองที่รับรู้เร็วขึ้น แม้ไม่จำเป็นต้องลดต้นทุนหรือเวลาสำเร็จทั้งหมด แสดงเฉพาะชิ้นที่มีเนื้อหา และจัดการกรณีถูกขัดจังหวะและหมดเวลา
Python streaming example
อ่านชิ้นส่วนคำตอบแบบเพิ่มขึ้นใน Python
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1", timeout=180.0)
stream = client.chat.completions.create(
model="muse-wonder",
messages=[{"role": "user", "content": "Design a scalable FastAPI service."}],
stream=True,
)
parts = []
for chunk in stream:
if not chunk.choices:
continue
content = chunk.choices[0].delta.content
if content:
print(content, end="", flush=True)
parts.append(content)
print("\nResponse complete.")
JavaScript streaming example
อ่านชิ้นส่วนคำตอบแบบเพิ่มขึ้นใน Node.js
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.COMETAPI_KEY,
baseURL: "https://api.cometapi.com/v1",
});
const stream = await client.chat.completions.create({
model: "muse-wonder",
messages: [{role: "user", content: "Outline a research agent."}],
stream: true,
});
for await (const chunk of stream) {
const text = chunk.choices?.[0]?.delta?.content;
if (text) process.stdout.write(text);
}
What Reasoning Effort Levels Does Muse Wonder Support?
Supported Reasoning Effort Values
โมเดลเนทีฟยอมรับ minimal, low, medium, high, xhigh และ max; ไม่มีค่าสถานะที่ไม่รองรับ เริ่มต้นด้วยการตั้งค่าระดับปานกลางและเพิ่มขึ้นเฉพาะเมื่อการประเมินของคุณยืนยันว่าคุ้มกับความหน่วงและค่าโทเค็นที่สูงขึ้น ดู เอกสารอ้างอิงการให้เหตุผลของ Meta ทดสอบการส่งต่อของเกตเวย์แยกต่างหาก
How to Set Reasoning Effort in Chat Completions
ตัวอย่างต่อไปนี้ส่งค่า high ผ่านเกตเวย์เพื่อทดสอบความสามารถ หากถูกปฏิเสธ ให้ตรวจสอบข้อผิดพลาดก่อนลบฟิลด์: สถานะ 400 อาจบ่งชี้ข้อความไม่ถูกต้อง โมเดลไม่ถูกต้อง หรือปัญหาอื่นในคำขอ ลองใหม่ด้วยคำขอข้อความขั้นต่ำเพื่อแยกหาสาเหตุ
ทดสอบความพยายามด้าน reasoning ระดับ high บนเกตเวย์
import os
from openai import OpenAI, BadRequestError
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1")
try:
response = client.chat.completions.create(
model="muse-wonder",
messages=[{"role": "user", "content": "Diagnose a distributed timeout."}],
extra_body={"reasoning_effort": "high"},
)
print(response.choices[0].message.content)
except BadRequestError as err:
print("This reasoning parameter may not be accepted:", err)
How to Set Reasoning Effort in the Responses API
Responses API เนทีฟของ Meta จัดฟิลด์นี้แบบซ้อนเป็น reasoning.effort และใช้ muse-wonder-1.0 ตัวอย่างด้านล่างใช้ข้อมูลรับรองของ Meta และเอ็นด์พอยต์เนทีฟ; ยืนยันการรองรับ Responses แยกต่างหากก่อนปรับให้ใช้กับ CometAPI
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["META_API_KEY"],
base_url="https://api.meta.ai/v1",
)
response = client.responses.create(
model="muse-wonder-1.0",
input="Diagnose a distributed timeout.",
reasoning={"effort": "high"},
)
print(response.output_text)
Why max Does Not Select Muse Wonder Full
max เปลี่ยนงบประมาณการให้เหตุผลของโมเดลที่เลือก ไม่ได้เปลี่ยนตัวระบุโมเดลหรือให้สิทธิ์เข้าถึง Full; ความแตกต่างด้านการเข้าถึงอธิบายไว้ในบทนำของโมเดล
How Can Muse Wonder API Analyze Images and PDFs
Meta จัดทำเอกสาร อินพุตภาพ วิดีโอ เสียง และ PDF สำหรับ Wonder เนทีฟ การรองรับสื่อโดยเนทีฟของ Meta ไม่ได้การันตีว่า CometAPI จะยอมรับสคีมาคอนเทนต์ รูปแบบ URL ประเภทไฟล์ หรือขนาดไฟล์เดียวกัน ตรวจสอบรายละเอียดเหล่านั้นบนเส้นทางที่เลือกก่อนใช้งานจริง ตัวอย่าง image_url ด้านล่างเป็นรูปแบบเพื่อความเข้ากันได้: ใช้ภาพที่เข้าถึงได้และคุณควบคุมได้ ยืนยันการรองรับเอ็นด์พอยต์ และตรวจคำตอบกับรายละเอียดที่มองเห็นได้
ทดสอบ URL ของภาพด้วยรูปภาพที่ทราบแน่ชัด
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1")
response = client.chat.completions.create(
model="muse-wonder",
messages=[{"role": "user", "content": [
{"type": "text", "text": "Describe anomalies in this dashboard."},
{"type": "image_url", "image_url": {
"url": "https://example.com/dashboard.png"}},
]}],
)
print(response.choices[0].message.content)
สำหรับเวิร์กโฟลว์ PDF แบบข้อความล้วนที่คาดเดาได้ ให้ดึงข้อความที่เลือกได้ภายในเครื่องและส่งย่อหน้าที่เลือกเป็นข้อความ วิธีนี้ไม่ได้ทดสอบอินพุต PDF เนทีฟหรือคงรูปแบบหน้า รูป หรือคอนเทนต์สแกนไว้ ตัวอย่างจำกัดอินพุตไว้ 50,000 อักขระสำหรับการทดสอบเล็กๆ; การดึงเข้าระบบจริงควรเลือกหรือแบ่งชิ้นคอนเทนต์และคงการอ้างอิงเลขหน้าไว้ แทนที่จะตัดรายงานทิ้งโดยไม่แจ้ง
ดึงข้อความ PDF ที่เลือกได้สำหรับการทดสอบแบบมีขอบเขต
# pip install pymupdf openai
import os
import fitz
from openai import OpenAI
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1")
with fitz.open("report.pdf") as doc:
document_text = "\n".join(p.get_text() for p in doc)
response = client.chat.completions.create(
model="muse-wonder",
messages=[{"role": "user", "content":
"Summarize the risks in this report:\n" + document_text[:50000]}],
)
print(response.choices[0].message.content)
How Can You Build a Tool-Calling Agent With Muse Wonder API
โมเดลสามารถร้องขอให้เรียกฟังก์ชันได้ แต่แอปพลิเคชันต้องอนุญาตและดำเนินการ ตัวอย่างนี้สาธิตการค้นหาสถานะคำสั่งซื้อแบบจำกัดและอ่านอย่างเดียว; การใช้งานจริงควรตรวจสอบความถูกต้องของอินพุตและจำกัดเครื่องมือตามสิทธิ์
ดำเนินการคำขอเครื่องมือสำหรับสถานะคำสั่งซื้อแบบจำกัด
import json, os
from openai import OpenAI
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1")
tools = [{"type": "function", "function": {
"name": "get_order_status",
"description": "Look up an order status",
"parameters": {"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"], "additionalProperties": False}
}}]
messages = [{"role": "user", "content": "Status of order A1001?"}]
r = client.chat.completions.create(model="muse-wonder",
messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message
messages.append(msg)
if msg.tool_calls:
for call in msg.tool_calls:
if call.function.name != "get_order_status":
raise ValueError("Tool not permitted")
args = json.loads(call.function.arguments)
status = {"A1001": "Shipped"}.get(args["order_id"], "Not found")
messages.append({"role": "tool", "tool_call_id": call.id,
"content": json.dumps({"status": status})})
r = client.chat.completions.create(model="muse-wonder",
messages=messages, tools=tools)
print(r.choices[0].message.content)
else:
print(msg.content)
ตัวอย่างเพื่อการสอนนี้จัดการรอบการเรียกเครื่องมือหนึ่งครั้ง หากคำตอบถัดไปร้องขอการเรียกเครื่องมืออีกครั้ง ให้ดำเนินการต่อภายในลูปที่มีขอบเขตและตรวจสอบชื่อและอาร์กิวเมนต์อีกครั้ง บันทึกผลลัพธ์ของเครื่องมือเพื่อความปลอดภัยในการลองใหม่; เอเจนต์ระดับโปรดักชันยังต้องมีการจำกัดเวลา จำนวนรอบ และเงื่อนไขการเสร็จสิ้นที่ชัดเจน
How Much Does Muse Wonder API Cost
ราคาอย่างเป็นทางการของ Meta ระบุ $4.00 ต่อหนึ่งล้านโทเค็นอินพุตที่ไม่แคช, $0.20 ต่อหนึ่งล้านโทเค็นอินพุตที่แคช และ $20.00 ต่อหนึ่งล้านโทเค็นเอาต์พุต
บทความแหล่งอ้างอิง ณ วันที่ 14 ตุลาคม 2026 ระบุ CometAPI ที่ $3.20 ต่อหนึ่งล้านโทเค็นอินพุตที่ไม่แคช และ $16.00 ต่อหนึ่งล้านโทเค็นเอาต์พุต อัตราเหล่านี้คืออัตราของเกตเวย์ ไม่ใช่การแทนที่ราคาของ Meta ที่ $4.00 สำหรับอินพุตและ $20.00 สำหรับเอาต์พุต ตรวจสอบอัตราบัญชีและเส้นทางปัจจุบันก่อนใช้งาน; ไม่ได้สมมุติว่ามีอัตราส่วนลดสำหรับอินพุตที่แคชใน CometAPI
| Per 1M tokens | Meta native API | Muse Wonder API in CometAPI |
|---|---|---|
| Uncached input | $4.00 | $3.20 |
| Cached input | $0.20 | Confirm route tariff |
| Output | $20.00 | $16.00 |
สำหรับ 100,000 โทเค็นอินพุตที่ไม่แคช และ 50,000 โทเค็นเอาต์พุตที่เรียกเก็บเงิน อัตราของ Meta ที่แสดงให้ $0.40 + $1.00 = $1.40 อัตราของ CometAPI ที่แสดงให้ $0.32 + $0.80 = $1.12 ตัวอย่างนี้ไม่รวมค่าบริการเพิ่มเติมและไม่ได้สมมุติส่วนลดจากแคช
สำหรับกรณีไม่แคชนี้ อัตราของ CometAPI ที่แสดงให้การประเมินต่ำลง 20% ใบแจ้งหนี้จริงขึ้นกับการใช้โทเค็น เส้นทางการเรียกเก็บเงิน และค่าบริการเพิ่มเติม หากมีการแคช ให้คำนวณด้วยอัตราที่ตรวจสอบแล้วสำหรับการแคช แทนการใช้อัตราอินพุตที่ไม่แคชกับทุกโทเค็น
ประเมินต้นทุนด้วยอัตรา CometAPI ในสแนปชอตแหล่งข้อมูล; แทนที่ด้วยอัตราบัญชีที่คุณตรวจสอบแล้ว
def estimate_cost(input_tokens, output_tokens,
input_rate=3.20, output_rate=16.00):
if input_tokens < 0 or output_tokens < 0:
raise ValueError('Token counts must be non-negative')
return (input_tokens * input_rate
+ output_tokens * output_rate) / 1_000_000
print(estimate_cost(100000, 50000)) # 1.12
How to Migrate and Run Muse Wonder in Production
Update and Validate the Integration
การผสานรวมด้วยไคลเอนต์ที่เข้ากันได้กับ OpenAI ส่วนใหญ่สามารถคงโครงสร้างโดยรวมไว้ได้ อัปเดต base URL ข้อมูลรับรอง และรหัสโมเดล แล้วรันการประเมินแบบแบ่งเฟสด้วยพรอมป์ตจริง ฟิลด์เฉพาะโปรโตคอลสำหรับการให้เหตุผลและมัลติโหมดต้องยืนยันแยกต่างหาก
ตั้งค่า COMETAPI_KEY, อัปเดต base URL เป็น https://api.cometapi.com/v1 และเลือก muse-wonder ยืนยันการยืนยันสิทธิ์และการเข้าถึงโมเดลด้วยคำขอข้อความขั้นต่ำ จากนั้นทดสอบฟิลด์ reasoning, ชิ้นส่วนการสตรีม, การดำเนินการเรียกเครื่องมือ และรูปแบบสื่อใดๆ แยกกัน ตรวจสอบข้อผิดพลาดและคุณภาพคำตอบ: HTTP 400 อาจมีหลายสาเหตุ ในขณะที่การตอบกลับ HTTP สำเร็จเพียงอย่างเดียวไม่ได้พิสูจน์การรองรับความสามารถ บันทึก usage ที่ส่งกลับและเปรียบเทียบต้นทุนกับงบประมาณของคุณ เก็บ base URL และโมเดลให้กำหนดค่าได้เพื่อให้ย้อนกลับได้
กำหนดการย้ายและย้อนกลับโดยขับเคลื่อนด้วยสภาพแวดล้อม
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url=os.getenv("AI_BASE_URL", "https://api.cometapi.com/v1"),
)
model = os.getenv("AI_MODEL", "muse-wonder")
r = client.chat.completions.create(
model=model,
messages=[{"role":"user", "content":"Review this API design."}],
)
print(r.choices[0].message.content)
เริ่มด้วยการส่งทราฟฟิกจริงส่วนเล็กแบบ canary เปรียบเทียบความถูกต้อง ความสำเร็จของเครื่องมือ ความหน่วงโทเค็นแรก ความหน่วงรวม อัตราการลองใหม่ และต้นทุนรวมต่อหนึ่งงานที่เสร็จสิ้นสำเร็จก่อนขยายการเปิดใช้งาน
Add Timeouts, Retry Limits and Monitoring
ตั้งค่า timeouts และขีดจำกัดอย่างชัดเจน; บันทึก ID คำขอที่ไม่อ่อนไหวและการใช้โทเค็น; ปิดบังข้อมูลส่วนบุคคลเมื่อเป็นไปได้; ลองใหม่เฉพาะความล้มเหลวแบบชั่วคราว; และต้องมีการอนุญาตสำหรับการกระทำของเครื่องมือที่ไม่สามารถย้อนกลับได้ คำเรียกโมเดลที่ถูกกว่า ไม่จำเป็นต้องหมายถึงงานที่ถูกกว่า หากทำให้เกิดการลองใหม่
ลองใหม่ความผิดพลาดชั่วคราวด้วย exponential backoff ที่มีขอบเขต
import os, time, random
from openai import (OpenAI, APIConnectionError, APITimeoutError,
RateLimitError, InternalServerError)
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1", timeout=60, max_retries=0)
def complete_with_retry(prompt, attempts=4):
for i in range(attempts):
try:
r = client.chat.completions.create(
model="muse-wonder",
messages=[{"role": "user", "content": prompt}])
return r.choices[0].message.content
except (RateLimitError, APIConnectionError,
APITimeoutError, InternalServerError):
if i == attempts-1:
raise
time.sleep(min(2**i, 16) + random.uniform(0, 0.5))
ตัวชี้วัดการดำเนินงานที่แนะนำ: ต้นทุนต่อหนึ่งงานที่สำเร็จ = ต้นทุนโมเดลและเครื่องมือรวม / จำนวนงานที่สำเร็จ ติดตามทั้งราวกั้นด้านความปลอดภัยและความถูกต้อง รวมถึงต้นทุนรวม
FAQ
Why can Muse Wonder API stop before its final answer?
งบประมาณร่วมกันระหว่างการให้เหตุผลและข้อความที่มองเห็นได้บน API เนทีฟ การให้เหตุผลยาวอาจเหลือพื้นที่สำหรับคำตอบสุดท้ายลดลง ตรวจสอบ finish reason และ usage ปรับลดความพยายามหรือจำกัดขอบเขตงาน และเพิ่มขีดจำกัดการทำงานให้จบตามที่เส้นทางรองรับภายในงบประมาณของคุณ สตรีมที่ถูกขัดจังหวะต้องวินิจฉัยการขนส่งแยกต่างหาก
Should I retry a Muse Wonder API stream from the beginning?
คำขอใหม่คือการสร้างใหม่ ไม่ใช่การต่ออัตโนมัติจากคำตอบที่ถูกขัดจังหวะ บันทึกผลลัพธ์บางส่วนและตัวระบุคำขอ ทำเครื่องหมายคำตอบว่ายังไม่สมบูรณ์ และตัดสินใจว่าจะเริ่มใหม่หรือขอให้ต่อเนื้อหาโดยระบุบริบทอย่างชัดเจน สำหรับเวิร์กโฟลว์เครื่องมือ ให้คงผลลัพธ์ที่เสร็จแล้วเพื่อไม่ให้การลองใหม่ดำเนินการซ้ำสอง
How do I validate Muse Wonder API media answers?
ใช้ภาพหรือเอกสารทดสอบเล็กๆ ที่มีข้อเท็จจริงซึ่งคุณรู้แน่ชัด และตั้งคำถามที่คำตอบต้องอาศัยข้อเท็จจริงเหล่านั้น เปรียบเทียบคำตอบกับต้นฉบับ รวมถึงตัวเลขและการอ้างอิงหน้า สถานะ HTTP สำเร็จเพียงอย่างเดียวไม่ได้พิสูจน์ว่าเอ็นด์พอยต์ยอมรับหรือแปลความสื่ออย่างถูกต้อง; ตรวจสอบข้อผิดพลาดและรูปแบบคำขอก่อนขยายการดึงเข้า
How can I audit a Muse Wonder API cost discrepancy?
บันทึก usage, โมเดล, เส้นทาง, เวลาเรียก และอัตราบัญชีในขณะนั้น แยกอินพุตที่ไม่แคช การอ่านจากแคชที่ยืนยันแล้ว และเอาต์พุตที่เรียกเก็บเงินรวม รวมถึงการให้เหตุผลหากมี เปรียบเทียบปริมาณเหล่านี้กับบันทึกการเรียกเก็บเงิน; ตรวจสอบสกุลเงิน การเปลี่ยนอัตรา และค่าบริการเพิ่มเติมก่อนสรุปว่าเป็นข้อผิดพลาดในการนับโทเค็น
Conclusion
เริ่มจากคำขอ CometAPI ที่ยืนยันสิทธิ์หนึ่งรายการ ยืนยันคำตอบที่ส่งกลับ จากนั้นเพิ่มการสตรีมและความสามารถที่แอปพลิเคชันของคุณต้องการ ก่อนเปิดใช้งานจริง ให้ตรวจสอบเส้นทางที่เลือก ยืนยันการเรียกเก็บเงิน บังคับใช้สิทธิ์ของเครื่องมือ และเก็บโมเดลสำหรับย้อนกลับ ขยายทราฟฟิกเฉพาะเมื่อผลสำเร็จของงาน ความหน่วง และต้นทุนที่วัดได้ตรงตามเกณฑ์ยอมรับของคุณ