Cara menggunakan Muse Wonder API: Python, penstriman & harga

TL;DR

Muse Wonder ialah model pratonton Meta untuk pengaturcaraan kompleks, penaakulan dan aliran kerja berorientasikan agen. Pembangun boleh mengakses Muse Wonder API dalam CometAPI menggunakan klien yang serasi dengan OpenAI dan model="muse-wonder". Panduan ini membantu pembangun yang biasa dengan Python atau JavaScript menghantar permintaan pertama, menambah penstriman, serta menilai penaakulan, media dan kos. Berbanding Muse Spark, sebab praktikal untuk menilai Wonder ialah potensinya menyiapkan tugas sukar dengan lebih boleh dipercayai; tetingkap konteks yang besar semata-mata bukan sebab untuk berhijrah.

Key Takeaways

• Integrasi: gunakan kunci API backend, https://api.cometapi.com/v1, dan model="muse-wonder".
• Kapasiti: Muse Wonder mempunyai tetingkap konteks 1,048,576 token; potong konteks berulang untuk mengawal kos.
• Keupayaan: nilai penstriman, panggilan alat dan media secara berasingan pada laluan gateway yang dipilih.
• Penaakulan: Muse Wonder natif menyokong minimal hingga max; usaha yang lebih tinggi meningkatkan penggunaan token dan latensi.
• Pengeluaran: penanda aras tugas sebenar, sahkan pengebilan semasa, dan kekalkan model rollback sebelum memperluas trafik.

What Is Muse Wonder API?

Meta memperkenalkan Muse Wonder pada 12 Oktober 2026. Model ini tersedia dalam pratonton melalui Meta Model API untuk pengaturcaraan kompleks, penaakulan dan aliran kerja dipacu alat. CometAPI menggunakan pengecam model muse-wonder; pengecam natif Meta ialah muse-wonder-1.0.

Model natif memfokus pada penaakulan berterusan, pengaturcaraan dan kerja dipacu alat. Aplikasi masih perlu membekalkan alat, keadaan berterusan, syarat berhenti dan semakan kebenaran; panggilan model individu tidak mewujudkan persekitaran pelaksanaan autonomi.

Muse Wonder API specifications

Muse Wonder vs Muse Wonder Full

Muse Wonder tersedia melalui Meta Model API; Muse Wonder Full hanya tersedia melalui langganan Power Usage dan Maximum Usage dalam Muse Code, dan menetapkan reasoning_effort kepada max tidak akan bertukar kepada Muse Wonder Full. Rujuk pengumuman pelancaran Meta.

Muse Spark API vs Muse Wonder API

Pilih antara model berdasarkan kejayaan tugas terukur dan kos. Panduan model natif mengesyorkan Wonder untuk kerja kompleks dan Spark untuk beban kerja sensitif kos; kedua-duanya diberikan tetingkap konteks 1,048,576 token. Bandingkan versi Spark tertentu dan jangan anggap semua versi mempunyai keupayaan yang sama.

Muse Spark lebih sesuai untuk beban kerja sensitif kos; Muse Wonder menyasarkan pengaturcaraan kompleks dan penaakulan berterusan. Sahkan sokongan media, kawalan penaakulan dan pengebilan untuk versi model dan laluan gateway yang tepat. Kekalkan model yang memenuhi sasaran kejayaan tugas dan kos yang anda ukur.

How to Use Muse Wonder API with CometAPI Step by Step

Step 1: Create and secure your CometAPI key

Cipta akaun, jana kunci API backend, dan pastikan ia tidak berada dalam kod pelayar atau repositori awam. Ikuti dokumentasi integrasi CometAPI untuk pengesahan. Contoh ini memerlukan akaun yang dibiayai atau layak, Python 3.10+ atau persekitaran Node.js LTS yang disokong, dan akses HTTPS keluar. Simpan contoh JavaScript sebagai fail .mjs.

Tetapkan kunci API dalam sesi Bash.

export COMETAPI_KEY="your_cometapi_api_key"

Tetapkan kunci API dalam sesi PowerShell.

$env:COMETAPI_KEY="your_cometapi_api_key"

Step 2: Configure the Muse Wonder endpoint

Step 3: Send your first request with cURL

Hantar permintaan chat minimum dengan pengesahan.

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": "Anda seorang jurutera kanan."},
      {"role": "user", "content": "Senaraikan tiga cara untuk meningkatkan kebolehpercayaan API Python."}
    ],
    "stream": false
  }' 

Permintaan tanpa penstriman yang berjaya sepatutnya memulangkan choices[0].message.content. Periksa model dan penggunaan yang dipulangkan, jika dibekalkan, dan sahkan teksnya menjawab prompt anda. Kegagalan pengesahan memerlukan semakan kelayakan; ralat model tidak sah memerlukan semakan akses model. Contoh menunjukkan corak permintaan dan bukan mewakili latensi atau hasil penanda aras yang diukur.

Step 4: Make a Python request

Pasang perpustakaan klien Python.

pip install --upgrade openai

Hantar permintaan Python dan periksa penggunaan token.

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": "Anda seorang jurutera Python."},
        {"role": "user", "content": "Ulasan: 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

Pasang perpustakaan klien JavaScript.

npm install openai

Hantar permintaan 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: "Terangkan async/await."}],
});
console.log(response.choices[0].message.content);

How to Stream Muse Wonder Responses with CometAPI

Penstriman memulangkan cebisan respons beransur-ansur melalui server-sent events. Ia meningkatkan responsif yang dirasakan, walaupun tidak semestinya kos atau masa siap keseluruhan. Hanya paparkan cebisan yang mengandungi kandungan, dan tangani kes gangguan serta had masa.

Python streaming example

Baca cebisan respons Python beransur-ansur.

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": "Reka bentuk perkhidmatan FastAPI yang boleh diskala."}],
    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("\nRespons lengkap.")

JavaScript streaming example

Baca cebisan respons Node.js beransur-ansur.

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: "Huraikan rangka agen penyelidikan."}],
  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

Model natif menerima minimal, low, medium, high, xhigh dan max; tiada yang tidak disokong. Mulakan dengan tetapan sederhana dan naikkan hanya apabila penilaian anda membenarkan peningkatan latensi dan kos token output. Lihat rujukan penaakulan Meta. Uji penghantaran gateway secara berasingan.

How to Set Reasoning Effort in Chat Completions

Contoh berikut menghantar high melalui gateway sebagai ujian keupayaan. Jika ditolak, periksa ralat sebelum membuang medan tersebut: 400 juga boleh menunjukkan mesej tidak sah, model tidak betul atau isu permintaan lain. Cuba semula dengan permintaan teks minimum untuk mengasingkan punca.

Uji usaha penaakulan high pada gateway.

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": "Kenal pasti punca masa tamat teragih."}],
        extra_body={"reasoning_effort": "high"},
    )
    print(response.choices[0].message.content)
except BadRequestError as err:
    print("Parameter penaakulan ini mungkin tidak diterima:", err)

How to Set Reasoning Effort in the Responses API

Responses API natif Meta meletakkan medan sebagai reasoning.effort dan menggunakan muse-wonder-1.0. Contoh di bawah menggunakan kelayakan Meta dan endpoint natifnya; sahkan sokongan Responses secara berasingan sebelum menyesuaikannya ke 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="Kenal pasti punca masa tamat teragih.",
    reasoning={"effort": "high"},
)
print(response.output_text)

Why max Does Not Select Muse Wonder Full

max mengubah bajet penaakulan bagi model yang dipilih. Ia tidak menukar pengecam model atau memberikan akses kepada Full; perbezaan akses dijelaskan dalam pengenalan model.

How Can Muse Wonder API Analyze Images and PDFs

Meta mendokumenkan input imej, video, audio dan PDF untuk Wonder natif. Sokongan media natif Meta tidak menjamin CometAPI menerima skema kandungan, format URL, jenis fail atau had saiz yang sama. Sahkan butiran tersebut pada laluan yang dipilih sebelum penggunaan produksi. Contoh image_url di bawah ialah corak keserasian: gunakan imej boleh akses yang anda kawal, sahkan sokongan endpoint, dan semak jawapan dengan butiran yang kelihatan.

Uji URL imej dengan imej yang diketahui.

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": "Huraikan anomali dalam papan pemuka ini."},
        {"type": "image_url", "image_url": {
            "url": "https://example.com/dashboard.png"}},
    ]}],
)
print(response.choices[0].message.content)

Untuk aliran kerja PDF berasaskan teks yang boleh diramal, ekstrak teks boleh pilih secara setempat dan hantar petikan terpilih sebagai teks. Ini tidak menguji input PDF natif atau mengekalkan susun atur halaman, rajah atau kandungan imbasan. Contoh menghadkan input kepada 50,000 aksara untuk ujian kecil; pengingesan produksi harus memilih atau memecah kandungan dan mengekalkan rujukan halaman dan bukannya memotong laporan secara senyap.

Ekstrak teks PDF boleh pilih untuk ujian terhad.

# 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":
        "Ringkaskan risiko dalam laporan ini:\n" + document_text[:50000]}],
)
print(response.choices[0].message.content)

How Can You Build a Tool-Calling Agent With Muse Wonder API

Model boleh meminta panggilan fungsi, tetapi aplikasi mesti membenarkan dan melaksanakannya. Contoh ini menunjukkan satu carian status pesanan baca sahaja yang terikat; pelaksanaan produksi harus mengesahkan input dan mengehadkan alat mengikut kebenaran.

Laksanakan permintaan alat status pesanan yang terikat.

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": "Cari status pesanan",
    "parameters": {"type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"], "additionalProperties": False}
}}]
messages = [{"role": "user", "content": "Status pesanan 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("Alat tidak dibenarkan")
        args = json.loads(call.function.arguments)
        status = {"A1001": "Dihantar"}.get(args["order_id"], "Tidak ditemui")
        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)

Contoh pengajaran ini mengendalikan satu pusingan panggilan alat. Jika respons susulan meminta panggilan alat lain, teruskan hanya dalam gelung terikat dan sahkan semula namanya serta argumen. Kekalkan hasil alat untuk keselamatan cuba semula; agen produksi juga memerlukan had masa, had iterasi dan syarat penyiapan yang jelas.

How Much Does Muse Wonder API Cost

Harga rasmi Meta menyatakan $4.00 per sejuta token input tidak di-cache, $0.20 per sejuta token input di-cache, dan $20.00 per sejuta token output.

Petikan harga pada 14 Oktober 2026 dalam artikel sumber menyenaraikan CometAPI pada $3.20 per sejuta token input tidak di-cache dan $16.00 per sejuta token output. Ini ialah kadar gateway, bukan pengganti harga input $4.00 dan output $20.00 Meta. Sahkan kadar akaun dan laluan semasa anda sebelum penggunaan; tiada tarif input di-cache CometAPI yang dianggap.

Untuk 100,000 token input tidak di-cache dan 50,000 token output yang dibilkan, kadar Meta yang disenaraikan memberikan $0.40 + $1.00 = $1.40. Kadar CometAPI yang disenaraikan memberikan $0.32 + $0.80 = $1.12. Contoh ini mengecualikan caj tambahan dan tidak menganggap sebarang diskaun cache.

Untuk contoh tidak di-cache ini, kadar CometAPI yang dipaparkan memberikan anggaran 20% lebih rendah. Invois sebenar bergantung pada penggunaan token, pengebilan laluan dan sebarang caj tambahan. Jika cache digunakan, kira menggunakan tarif cache yang disahkan dan bukannya menerapkan kadar input tidak di-cache pada setiap token.

Anggarkan kos dengan kadar CometAPI dalam petikan sumber; gantikan dengan kadar akaun anda yang disahkan.

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('Kiraan token mestilah tidak negatif')
    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

Kebanyakan integrasi klien serasi OpenAI boleh mengekalkan strukturnya. Kemas kini base URL, kelayakan dan ID model, kemudian jalankan penilaian berperingkat pada prompt sebenar. Medan penaakulan dan multimodal khusus protokol memerlukan pengesahan berasingan.

Tetapkan COMETAPI_KEY, kemas kini base URL kepada https://api.cometapi.com/v1 dan pilih muse-wonder. Sahkan pengesahan dan akses model dengan permintaan teks minimum. Kemudian uji medan penaakulan, cebisan penstriman, pelaksanaan panggilan alat dan mana-mana format media secara berasingan. Periksa ralat dan kualiti jawapan: HTTP 400 boleh mempunyai beberapa punca, manakala respons HTTP yang berjaya sahaja tidak membuktikan sokongan keupayaan. Rekod penggunaan yang dipulangkan dan bandingkan kos dengan bajet anda. Kekalkan base URL dan model boleh dikonfigurasi supaya anda boleh rollback.

Konfigurasikan migrasi dan rollback dipacu persekitaran.

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":"Semak reka bentuk API ini."}],
)
print(r.choices[0].message.content)

Mulakan dengan pecahan kanari kecil trafik langsung. Bandingkan ketepatan, kejayaan alat, latensi token pertama, latensi keseluruhan, kadar cuba semula dan jumlah kos per tugas yang berjaya disiapkan sebelum memperluas pengeluaran.

Add Timeouts, Retry Limits and Monitoring

Tetapkan had masa permintaan dan had jelas; log ID permintaan dan penggunaan token tanpa sensitif; gelapkan maklumat peribadi bila mungkin; cuba semula hanya kegagalan sementara; dan minta kebenaran untuk tindakan alat yang tidak boleh dipulihkan. Panggilan model yang lebih murah tidak semestinya menjadikan tugas lebih murah jika ia menyebabkan cuba semula.

Cuba semula ralat sementara dengan backoff eksponen terikat.

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

Metrik operasi yang disarankan: kos per tugas berjaya = jumlah kos model dan alat / bilangan tugas berjaya. Jejaki pagar keselamatan dan ketepatan serta kos agregat.

FAQ

Why can Muse Wonder API stop before its final answer?

Penaakulan dan teks yang kelihatan berkongsi bajet penyiapan pada API natif. Laluan penaakulan yang panjang boleh meninggalkan ruang yang lebih sedikit untuk jawapan akhir. Semak alasan penamat (finish reason) dan penggunaan, kurangkan usaha atau sempitkan tugas, dan tingkatkan had penyiapan yang disokong laluan hanya dalam bajet anda. Aliran yang terganggu memerlukan diagnosis pengangkutan berasingan.

Should I retry a Muse Wonder API stream from the beginning?

Permintaan baharu ialah generasi baharu, bukan sambungan automatik jawapan yang terganggu. Simpan output separa dan pengecam permintaan, tandakan jawapan tidak lengkap, dan putuskan sama ada untuk memulakan semula atau meminta sambungan menggunakan konteks yang jelas. Untuk aliran kerja alat, kekalkan tindakan yang telah selesai supaya cuba semula tidak melaksanakannya dua kali.

How do I validate Muse Wonder API media answers?

Gunakan imej atau dokumen kecil dengan fakta yang diketahui dan tanya soalan yang jawapannya memerlukan fakta tersebut. Bandingkan respons dengan asalnya, termasuk nombor dan rujukan halaman. Status HTTP berjaya sahaja tidak membuktikan bahawa endpoint menerima atau mentafsir media dengan betul; periksa ralat dan format permintaan sebelum menskalakan pengingesan.

How can I audit a Muse Wonder API cost discrepancy?

Rekod penggunaan yang dipulangkan, model, laluan, masa permintaan dan kadar akaun pada masa itu. Asingkan input tidak di-cache, bacaan cache yang disahkan dan jumlah output dibilkan, termasuk penaakulan jika berkenaan. Bandingkan kuantiti tersebut dengan rekod pengebilan; periksa mata wang, perubahan kadar dan caj tambahan sebelum menganggap ralat pengiraan token.

Conclusion

Mulakan dengan satu permintaan CometAPI yang diautentikasi, sahkan jawapan yang dipulangkan, kemudian tambah penstriman dan keupayaan yang diperlukan aplikasi anda. Sebelum pengeluaran, sahkan laluan yang dipilih, sahkan pengebilan, kuatkuasakan kebenaran alat dan kekalkan model rollback. Luaskan trafik hanya apabila kejayaan tugas terukur, latensi dan kos memenuhi kriteria penerimaan anda.