Cara Menggunakan Muse Wonder API: Python, Streaming & Harga

TL;DR

Muse Wonder adalah model pratinjau dari Meta untuk pengodean kompleks, penalaran, dan alur kerja agen. Developer dapat mengakses API Muse Wonder di CometAPI dengan klien yang kompatibel dengan OpenAI dan model="muse-wonder". Panduan ini membantu developer yang familier dengan Python atau JavaScript mengirim permintaan pertama, menambahkan streaming, serta mengevaluasi penalaran, media, dan biaya. Dibandingkan dengan Muse Spark, alasan praktis mengevaluasi Wonder adalah potensinya menyelesaikan tugas sulit dengan lebih andal; jendela konteks besar saja bukan alasan untuk bermigrasi.

Poin Penting

• Integrasi: gunakan kunci API backend, https://api.cometapi.com/v1, dan model="muse-wonder".
• Kapasitas: Muse Wonder memiliki jendela konteks 1,048,576 token; pangkas konteks berulang untuk mengendalikan biaya.
• Kapabilitas: evaluasi streaming, pemanggilan alat, dan media secara terpisah pada rute gateway yang dipilih.
• Penalaran: Muse Wonder native mendukung minimal hingga max; upaya lebih tinggi meningkatkan penggunaan token dan latensi.
• Deployment: benchmark tugas nyata, verifikasi penagihan saat ini, dan pertahankan model rollback sebelum memperluas trafik.

Apa itu Muse Wonder API?

Meta memperkenalkan Muse Wonder pada 12 Oktober 2026. Model ini tersedia dalam pratinjau melalui Meta Model API untuk pengodean kompleks, penalaran, dan alur kerja berbasis alat. CometAPI menggunakan pengenal model muse-wonder; pengenal native Meta adalah muse-wonder-1.0.

Model native berfokus pada penalaran berkelanjutan, pengodean, dan pekerjaan berbasis alat. Aplikasi tetap menyediakan alat, state persisten, kondisi penghentian, dan pemeriksaan izin; satu panggilan model tidak menciptakan lingkungan eksekusi otonom.

Spesifikasi Muse Wonder API

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 di Muse Code, dan mengatur reasoning_effort ke max tidak akan beralih ke Muse Wonder Full. Lihat pengumuman peluncuran Meta.

Muse Spark API vs Muse Wonder API

Pilih di antara model berdasarkan keberhasilan tugas yang terukur dan biaya. Panduan model native merekomendasikan Wonder untuk pekerjaan kompleks dan Spark untuk beban kerja sensitif biaya; keduanya diberi jendela konteks 1,048,576 token. Bandingkan versi Spark tertentu alih-alih mengasumsikan semua versi memiliki kapabilitas identik.

Muse Spark lebih cocok untuk beban kerja sensitif biaya; Muse Wonder menargetkan pengodean kompleks dan penalaran berkelanjutan. Verifikasi dukungan media, kontrol penalaran, dan penagihan untuk versi model dan rute gateway yang tepat. Pertahankan model yang memenuhi target keberhasilan tugas dan biaya yang terukur.

Cara Menggunakan Muse Wonder API dengan CometAPI Langkah demi Langkah

Langkah 1: Buat dan amankan kunci CometAPI Anda

Buat akun, hasilkan kunci API backend, dan simpan agar tidak berada di kode browser atau repositori publik. Ikuti dokumentasi integrasi CometAPI untuk autentikasi. Contoh ini memerlukan akun yang didanai atau memenuhi syarat, Python 3.10+ atau lingkungan Node.js LTS yang didukung, dan akses HTTPS keluar. Simpan contoh JavaScript sebagai file .mjs.

Setel kunci API di sesi Bash.

export COMETAPI_KEY="your_cometapi_api_key"

Setel kunci API di sesi PowerShell.

$env:COMETAPI_KEY="your_cometapi_api_key"

Langkah 2: Konfigurasikan endpoint Muse Wonder

Langkah 3: Kirim permintaan pertama Anda dengan cURL

Kirim permintaan chat terautentikasi minimal.

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
  }' 

Permintaan non-streaming yang berhasil seharusnya mengembalikan choices[0].message.content. Periksa model dan usage yang dikembalikan, bila tersedia, dan konfirmasikan bahwa teks menjawab prompt Anda. Kegagalan autentikasi memerlukan pemeriksaan kredensial; kesalahan model tidak valid memerlukan pemeriksaan akses model. Contoh mengilustrasikan pola permintaan dan tidak merepresentasikan latensi terukur atau hasil benchmark.

Langkah 4: Buat permintaan Python

Instal library klien Python.

pip install --upgrade openai

Kirim 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": "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)

Langkah 5: Gunakan JavaScript atau Node.js

Instal library klien JavaScript.

npm install openai

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

Cara Streaming Respons Muse Wonder dengan CometAPI

Streaming mengembalikan potongan respons secara inkremental melalui server-sent events. Ini meningkatkan responsivitas yang dirasakan, meski tidak selalu biaya atau waktu penyelesaian total. Hanya tampilkan potongan yang berisi konten, dan tangani kasus interupsi dan timeout.

Contoh streaming Python

Baca potongan respons Python secara bertahap.

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

Contoh streaming JavaScript

Baca potongan respons Node.js secara bertahap.

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

Tingkat Upaya Penalaran Apa yang Didukung Muse Wonder?

Nilai Upaya Penalaran yang Didukung

Model native menerima minimal, low, medium, high, xhigh, dan max; tidak ada yang tidak didukung. Mulailah dengan pengaturan moderat dan tingkatkan hanya ketika evaluasi Anda membenarkan tambahan latensi dan biaya token keluaran. Lihat referensi penalaran Meta. Uji penerusan gateway secara terpisah.

Cara Mengatur Upaya Penalaran di Chat Completions

Contoh berikut mengirim high melalui gateway sebagai uji kapabilitas. Jika ditolak, periksa kesalahannya sebelum menghapus field: 400 juga dapat mengindikasikan pesan tidak valid, model yang salah, atau masalah permintaan lain. Coba lagi dengan permintaan teks minimal untuk mengisolasi penyebabnya.

Uji upaya penalaran 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": "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)

Cara Mengatur Upaya Penalaran di Responses API

Responses API native Meta menempatkan field sebagai reasoning.effort dan menggunakan muse-wonder-1.0. Contoh di bawah menggunakan kredensial Meta dan endpoint native; konfirmasikan dukungan Responses secara independen sebelum mengadaptasikannya 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="Diagnose a distributed timeout.",
    reasoning={"effort": "high"},
)
print(response.output_text)

Mengapa max Tidak Memilih Muse Wonder Full

max mengubah anggaran penalaran dari model yang dipilih. Ini tidak mengubah pengenal model atau memberikan akses ke Full; perbedaan akses dijelaskan dalam pengantar model.

Bagaimana Muse Wonder API Menganalisis Gambar dan PDF

Meta mendokumentasikan masukan gambar, video, audio, dan PDF untuk Wonder native. Dukungan media native Meta tidak menjamin bahwa CometAPI menerima skema konten, format URL, tipe file, atau batas ukuran yang sama. Verifikasi detail tersebut pada rute yang dipilih sebelum penggunaan produksi. Contoh image_url di bawah adalah pola kompatibilitas: gunakan gambar yang dapat diakses dan Anda kendalikan, konfirmasi dukungan endpoint, dan periksa jawaban terhadap detail yang terlihat.

Uji URL gambar dengan gambar 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": "Describe anomalies in this dashboard."},
        {"type": "image_url", "image_url": {
            "url": "https://example.com/dashboard.png"}},
    ]}],
)
print(response.choices[0].message.content)

Untuk alur kerja PDF hanya teks yang dapat diprediksi, ekstrak teks yang dapat dipilih secara lokal dan kirim bagian terpilih sebagai teks. Ini tidak menguji masukan PDF native atau mempertahankan tata letak halaman, gambar, atau konten hasil pindai. Contoh membatasi masukan hingga 50.000 karakter untuk uji kecil; ingestion produksi harus memilih atau memotong konten dan mempertahankan referensi halaman alih-alih memotong laporan secara diam-diam.

Ekstrak teks PDF yang dapat dipilih untuk uji berbatas.

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

Bagaimana Anda Membangun Agen Pemanggilan Alat dengan Muse Wonder API

Model dapat meminta pemanggilan fungsi, namun aplikasi harus mengotorisasi dan mengeksekusinya. Contoh ini mendemonstrasikan satu pencarian status pesanan yang terbatas dan hanya-baca; implementasi produksi harus memvalidasi input dan membatasi alat berdasarkan izin.

Eksekusi permintaan alat status pesanan yang terbatas.

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)

Contoh pengajaran ini menangani satu putaran pemanggilan alat. Jika respons lanjutan meminta pemanggilan alat lain, lanjutkan hanya dalam loop terbatas dan validasi lagi nama serta argumennya. Persistenkan hasil alat untuk keamanan retry; agen produksi juga memerlukan batas waktu, batas iterasi, dan kondisi penyelesaian yang jelas.

Berapa Biaya Muse Wonder API

Harga resmi Meta menyatakan $4,00 per satu juta token masukan yang tidak di-cache, $0,20 per satu juta token masukan yang di-cache, dan $20,00 per satu juta token keluaran.

Snapshot harga artikel sumber per 14 Oktober 2026 mencantumkan CometAPI sebesar $3,20 per satu juta token masukan yang tidak di-cache dan $16,00 per satu juta token keluaran. Ini adalah tarif gateway, bukan pengganti harga masukan $4,00 dan keluaran $20,00 dari Meta. Konfirmasikan tarif akun dan rute Anda saat ini sebelum penggunaan; tidak diasumsikan adanya tarif masukan cache CometAPI.

Untuk 100.000 token masukan non-cache dan 50.000 token keluaran yang ditagihkan, tarif Meta yang tercantum memberikan $0.40 + $1.00 = $1.40. Tarif CometAPI yang tercantum memberikan $0.32 + $0.80 = $1.12. Contoh ini mengecualikan biaya tambahan dan tidak mengasumsikan diskon cache apa pun.

Untuk contoh non-cache ini, tarif CometAPI yang ditampilkan memberikan estimasi 20% lebih rendah. Tagihan nyata bergantung pada penggunaan token, penagihan rute, dan biaya tambahan apa pun. Jika caching berlaku, hitung menggunakan tarif cache yang terverifikasi daripada menerapkan tarif masukan non-cache ke setiap token.

Perkirakan biaya dengan tarif CometAPI pada snapshot sumber; ganti dengan tarif akun terverifikasi Anda.

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

Cara Migrasi dan Menjalankan Muse Wonder di Produksi

Perbarui dan Validasi Integrasi

Sebagian besar integrasi klien yang kompatibel dengan OpenAI dapat mempertahankan strukturnya. Perbarui base URL, kredensial, dan ID model, lalu jalankan evaluasi bertahap pada prompt nyata. Field khusus protokol untuk penalaran dan multimodal memerlukan verifikasi independen.

Set COMETAPI_KEY, perbarui base URL ke https://api.cometapi.com/v1 dan pilih muse-wonder. Verifikasi autentikasi dan akses model dengan permintaan teks minimal. Lalu uji field penalaran, potongan streaming, eksekusi pemanggilan alat, dan format media apa pun secara terpisah. Periksa kesalahan dan kualitas jawaban: HTTP 400 dapat memiliki beberapa penyebab, sementara respons HTTP yang berhasil saja tidak membuktikan dukungan kapabilitas. Catat usage yang dikembalikan dan bandingkan biaya dengan anggaran Anda. Jaga base URL dan model tetap dapat dikonfigurasi agar Anda dapat melakukan rollback.

Konfigurasikan migrasi dan rollback berbasis environment.

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)

Mulailah dengan fraksi kanari kecil dari trafik live. Bandingkan kebenaran, keberhasilan alat, latensi token pertama, latensi total, tingkat retry, dan total biaya per tugas yang berhasil diselesaikan sebelum memperluas peluncuran.

Tambahkan Timeout, Batas Retry, dan Monitoring

Tetapkan timeout permintaan dan batas eksplisit; log ID permintaan non-sensitif dan penggunaan token; redaksi informasi pribadi bila memungkinkan; retry hanya kegagalan sementara; dan minta otorisasi untuk tindakan alat yang tidak dapat dibalik. Panggilan model yang lebih murah tidak selalu berarti tugas lebih murah jika menyebabkan retry.

Retry kesalahan sementara dengan exponential backoff terbatas.

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: biaya per tugas berhasil = total biaya model dan alat / jumlah tugas yang berhasil. Lacak pagar pengaman keamanan dan kebenaran serta biaya agregat.

FAQ

Mengapa Muse Wonder API dapat berhenti sebelum jawaban akhirnya?

Penalaran dan teks yang terlihat berbagi anggaran penyelesaian pada API native. Proses penalaran yang panjang dapat menyisakan ruang lebih sedikit untuk jawaban akhir. Periksa alasan penyelesaian dan usage, kurangi upaya atau persempit tugas, dan tingkatkan batas penyelesaian yang didukung rute hanya dalam batas anggaran Anda. Stream yang terputus memerlukan diagnosis transport terpisah.

Haruskah saya mengulang stream Muse Wonder API dari awal?

Permintaan baru adalah generasi baru, bukan kelanjutan otomatis dari jawaban yang terputus. Simpan keluaran parsial dan pengenal permintaan, tandai jawaban tidak lengkap, dan putuskan apakah akan memulai ulang atau meminta kelanjutan menggunakan konteks eksplisit. Untuk alur kerja alat, persistensikan tindakan yang telah selesai agar retry tidak mengeksekusinya dua kali.

Bagaimana cara memvalidasi jawaban media Muse Wonder API?

Gunakan gambar atau dokumen uji kecil dengan fakta yang diketahui dan ajukan pertanyaan yang jawabannya memerlukan fakta tersebut. Bandingkan respons dengan aslinya, termasuk angka dan referensi halaman. Status HTTP yang berhasil saja tidak membuktikan bahwa endpoint menerima atau menafsirkan media dengan benar; periksa kesalahan dan format permintaan sebelum meningkatkan ingestion.

Bagaimana saya dapat mengaudit ketidaksesuaian biaya Muse Wonder API?

Catat usage yang dikembalikan, model, rute, waktu permintaan, dan tarif akun saat itu. Pisahkan masukan non-cache, pembacaan cache terverifikasi, dan total keluaran yang ditagihkan, termasuk penalaran bila berlaku. Bandingkan kuantitas tersebut dengan catatan penagihan; periksa mata uang, perubahan tarif, dan biaya tambahan sebelum mengasumsikan kesalahan perhitungan token.

Kesimpulan

Mulailah dengan satu permintaan CometAPI terautentikasi, konfirmasikan jawaban yang dikembalikan, lalu tambahkan streaming dan kapabilitas yang dibutuhkan aplikasi Anda. Sebelum peluncuran produksi, validasi rute yang dipilih, verifikasi penagihan, terapkan izin alat, dan pertahankan model rollback. Perluas trafik hanya ketika keberhasilan tugas, latensi, dan biaya yang terukur memenuhi kriteria penerimaan Anda.