Bouwen met CometAPIHeb je één API voor meerdere modellen nodig?Test de workflow in Playground en maak daarna een API-sleutel aan wanneer het model en de kosten passen bij je use case.
Zo gebruikt u de Muse Wonder API: Python, streaming en prijzen
Leer hoe u de Muse Wonder API gebruikt met CometAPI. Volg Python- en JavaScript-voorbeelden voor streaming, redeneren, multimodale invoer, prijzen en migratie.
Bobby SpencerOnderzoeksteam voor AI-modellen en API
Muse Wonder is Meta’s previewmodel voor complexe coding-, reasoning- en agent-workflows. Ontwikkelaars kunnen toegang krijgen tot de Muse Wonder API in CometAPI met een OpenAI-compatibele client en model="muse-wonder". Deze gids helpt ontwikkelaars die bekend zijn met Python of JavaScript om een eerste request te versturen, streaming toe te voegen en reasoning, media en kosten te evalueren. Vergeleken met Muse Spark is de praktische reden om Wonder te evalueren de potentie om moeilijke taken betrouwbaarder te voltooien; een grote context window op zich is geen reden om te migreren.
Key Takeaways
Integratie: gebruik een backend-API-sleutel, https://api.cometapi.com/v1, en model="muse-wonder".
Capaciteit: Muse Wonder heeft een context window van 1.048.576 tokens; snoei herhaalde context om kosten te beheersen.
Mogelijkheden: evalueer streaming, toolaanroepen en media afzonderlijk op de gekozen gateway-route.
Implementatie: benchmark echte taken, verifieer actuele facturatie en behoud een rollback-model voordat je verkeer opschaalt.
What Is Muse Wonder API?
Meta introduceerde Muse Wonder op 12 oktober 2026. Het model is beschikbaar als preview via de Meta Model API voor complexe coding-, reasoning- en toolgestuurde workflows. CometAPI gebruikt de modelidentifier muse-wonder; Meta’s native identifier is muse-wonder-1.0.
Het native model richt zich op duurzame reasoning, coding en toolgestuurd werk. Applicaties leveren nog steeds tools, persistente state, stopcondities en machtigingscontroles; een afzonderlijke modelaanroep creëert geen autonome uitvoeringsomgeving.
Muse Wonder API specifications
Specificatie
Meta-modeldocumentatie
Ontwikkelaar
Meta
Release
12 oktober 2026
Native Meta-identifier
muse-wonder-1.0
CometAPI-identifier
muse-wonder
Native context window
1.048.576 tokens
Native inputs
Tekst, afbeelding, video, audio en PDF; gateway-indelingen vereisen aparte validatie
Output
Tekst
Native API-status
Preview
Streaming en tools
Native API-mogelijkheden; valideer de geselecteerde CometAPI-route
Volledige variant
Beschikbaar voor in aanmerking komende Muse Code-abonnementen; niet geselecteerd via reasoning_effort
Muse Wonder versus Muse Wonder Full
Muse Wonder is beschikbaar via de Meta Model API; Muse Wonder Full is alleen beschikbaar via de Power Usage- en Maximum Usage-abonnementen in Muse Code, en het instellen van reasoning_effort op max schakelt niet over naar Muse Wonder Full. Zie Meta’s launch announcement: https://dev.meta.ai/resources/blog/build-with-muse-wonder
Muse Spark API versus Muse Wonder API
Kies tussen de modellen op basis van gemeten taaksucces en kosten. De native modelgids raadt Wonder aan voor complex werk en Spark voor kostengevoelige workloads; beide hebben een context window van 1.048.576 tokens. Vergelijk een specifieke Spark-versie in plaats van aan te nemen dat alle versies identieke mogelijkheden hebben.
Muse Spark is beter geschikt voor kostengevoelige workloads; Muse Wonder richt zich op complexe coding en duurzame reasoning. Verifieer mediasupport, reasoning-besturing en facturatie voor exact die modelversie en gateway-route. Behoud het model dat voldoet aan je doelstellingen voor taaksucces en kosten.
How to Use Muse Wonder API with CometAPI Step by Step
Step 1: Create and secure your CometAPI key
Maak een account aan, genereer een backend-API-sleutel en houd deze uit browsercode en publieke repositories. Volg de CometAPI-integratiedocumentatie (https://apidoc.cometapi.com/) voor authenticatie. Deze voorbeelden vereisen een account met saldo of in aanmerking komend, Python 3.10+ of een ondersteunde Node.js LTS-omgeving, en uitgaande HTTPS-toegang. Sla JavaScript-voorbeelden op als .mjs-bestanden.
Stel de API-sleutel in een Bash-sessie in.
export COMETAPI_KEY="your_cometapi_api_key"
Stel de API-sleutel in een PowerShell-sessie in.
$env:COMETAPI_KEY="your_cometapi_api_key"
Step 2: Configure the Muse Wonder endpoint
Instelling
Waarde
Base URL
https://api.cometapi.com/v1
Chat-endpoint
/chat/completions
HTTP-methode
POST
Authorization
Bearer API key
Model
muse-wonder
Step 3: Send your first request with cURL
Verstuur een minimale geauthenticeerde chatrequest.
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": "Je bent een senior engineer."},
{"role": "user", "content": "Noem drie manieren om de betrouwbaarheid van een Python-API te verbeteren."}
],
"stream": false
}'
Een geslaagde niet-streamingrequest zou choices[0].message.content moeten retourneren. Inspecteer het geretourneerde model en usage, indien aanwezig, en bevestig dat de tekst je prompt beantwoordt. Authenticatiefouten vereisen controle van de credentials; een ongeldige model-fout vereist controle van de modeltoegang. Voorbeelden illustreren requestpatronen en vertegenwoordigen geen gemeten latentie of benchmarkresultaten.
Step 4: Make a Python request
Installeer de Python-clientbibliotheek.
pip install --upgrade openai
Verstuur een Python-request en inspecteer het tokengebruik.
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": "Je bent een Python-engineer."},
{"role": "user", "content": "Beoordeel: def divide(a,b): return a/b"},
],
)
print(response.choices[0].message.content)
if response.usage:
print("Totaal aantal tokens:", response.usage.total_tokens)
Streaming retourneert incrementele response-chunks via server-sent events. Het verbetert de ervaren snelheid, maar niet per se de totale kosten of voltooiingstijd. Toon alleen chunks met content, en behandel onderbreking- en timeout-cases.
Python streaming example
Lees incrementele Python-response-chunks.
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": "Ontwerp een schaalbare 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 voltooid.")
JavaScript streaming example
Lees incrementele Node.js-response-chunks.
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: "Geef een opzet voor een onderzoeksagent."}],
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
Het native model accepteert minimal, low, medium, high, xhigh en max; geen enkele is niet-ondersteund. Begin met een gematigde instelling en verhoog alleen als je evaluaties de extra latentie en outputtokenskosten rechtvaardigen. Zie de Meta reasoning reference: https://dev.meta.ai/docs/reasoning. Test gateway-forwarding afzonderlijk.
How to Set Reasoning Effort in Chat Completions
Het volgende voorbeeld verstuurt high via de gateway als capabilitytest. Als het wordt geweigerd, inspecteer dan de fout voordat je het veld verwijdert: een 400 kan ook duiden op ongeldige messages, een onjuist model of een ander requestprobleem. Probeer opnieuw met de minimale tekstrequest om de oorzaak te isoleren.
Test high reasoning_effort op de 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": "Diagnoseer een gedistribueerde time-out."}],
extra_body={"reasoning_effort": "high"},
)
print(response.choices[0].message.content)
except BadRequestError as err:
print("Deze reasoning-parameter wordt mogelijk niet geaccepteerd:", err)
How to Set Reasoning Effort in the Responses API
Meta’s native Responses API nest het veld als reasoning.effort en gebruikt muse-wonder-1.0. Het onderstaande voorbeeld gebruikt Meta-credentials en het native endpoint; bevestig Responses-ondersteuning afzonderlijk voordat je dit aanpast aan 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="Diagnoseer een gedistribueerde time-out.",
reasoning={"effort": "high"},
)
print(response.output_text)
Why max Does Not Select Muse Wonder Full
max wijzigt het reasoning-budget van het geselecteerde model. Het verandert niet de modelidentifier en verleent geen toegang tot Full; het toegangsverschil wordt uitgelegd in de modelintroductie.
How Can Muse Wonder API Analyze Images and PDFs
Meta documenteert afbeelding-, video-, audio- en PDF-input voor native Wonder: https://dev.meta.ai/docs/models. Meta’s native mediasupport garandeert niet dat CometAPI hetzelfde content-schema, URL-formaat, bestandstypen of limieten accepteert. Verifieer die details op de gekozen route voordat je het in productie gebruikt. Het onderstaande image_url-voorbeeld is een compatibiliteitspatroon: gebruik een toegankelijke afbeelding die je beheert, bevestig endpointondersteuning en controleer het antwoord aan de hand van zichtbare details.
Test een afbeeldings-URL met een bekende afbeelding.
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": "Beschrijf afwijkingen in dit dashboard."},
{"type": "image_url", "image_url": {
"url": "https://example.com/dashboard.png"}},
]}],
)
print(response.choices[0].message.content)
Voor een voorspelbare tekst-only PDF-workflow, extraheer lokaal selecteerbare tekst en stuur geselecteerde passages als tekst. Dit test geen native PDF-input en behoudt geen paginalay-out, figuren of gescand materiaal. Het voorbeeld beperkt input tot 50.000 tekens voor een kleine test; productie-inname zou content moeten selecteren of chunken en paginareferenties behouden in plaats van een rapport stilzwijgend af te kappen.
Extraheer selecteerbare PDF-tekst voor een begrensde test.
# 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":
"Vat de risico's in dit rapport samen:\n" + document_text[:50000]}],
)
print(response.choices[0].message.content)
How Can You Build a Tool-Calling Agent With Muse Wonder API
Een model kan om een function call vragen, maar de applicatie moet die autoriseren en uitvoeren. Dit voorbeeld demonstreert één begrensde, read-only orderlookup; productie-implementaties moeten inputs valideren en tools beperken op basis van permissies.
Voer een begrensde toolaanroep voor orderstatus uit.
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": "Zoek een orderstatus op",
"parameters": {"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"], "additionalProperties": False}
}}]
messages = [{"role": "user", "content": "Status van bestelling 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 niet toegestaan")
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)
Dit oefenvoorbeeld behandelt één ronde van een toolaanroep. Als de vervolgrespons om een andere toolaanroep vraagt, ga dan alleen door binnen een begrensde lus en valideer opnieuw de naam en argumenten. Bewaar toolresultaten voor retry-veiligheid; een productie-agent heeft ook een tijdslimiet, een iteratielimiet en een duidelijke voltooiingsconditie nodig.
De prijssnapshot van 14 oktober 2026 uit het bronartikel geeft voor CometAPI $3,20 per miljoen niet-gecachete inputtokens en $16,00 per miljoen outputtokens. Dit zijn gatewaytarieven, geen vervanging voor Meta’s $4,00 (input) en $20,00 (output). Bevestig je actuele account- en routetarieven vóór gebruik; er wordt geen CometAPI-cachetarief aangenomen.
Per 1M tokens
Meta native API
Muse Wonder API in CometAPI
Niet-gecachete input
$4,00
$3,20
Gecachete input
$0,20
Bevestig routetarief
Output
$20,00
$16,00
Voor 100.000 niet-gecachete inputtokens en 50.000 gefactureerde outputtokens leveren de vermelde Meta-tarieven $0,40 + $1,00 = $1,40 op. De vermelde CometAPI-tarieven leveren $0,32 + $0,80 = $1,12 op. Dit voorbeeld sluit extra kosten uit en veronderstelt geen cached-korting.
Voor dit niet-gecachete voorbeeld geven de weergegeven CometAPI-tarieven een 20% lagere schatting. Werkelijke facturen hangen af van tokengebruik, routefacturatie en eventuele aanvullende kosten. Als caching van toepassing is, bereken dit met het geverifieerde cachetarief in plaats van het inputtarief voor niet-gecachete tokens op alle tokens toe te passen.
Schat de kosten met de CometAPI-tarieven uit de bron-snapshot; vervang ze door je geverifieerde accounttarieven.
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
De meeste OpenAI-compatibele clientintegraties kunnen hun algemene structuur behouden. Werk de base URL, credential en model-ID bij en voer vervolgens een gefaseerde evaluatie uit op echte prompts. Protocolspecifieke reasoning- en multimodale velden vereisen onafhankelijke verificatie.
Stel COMETAPI_KEY in, update de base URL naar https://api.cometapi.com/v1 en selecteer muse-wonder. Verifieer authenticatie en modeltoegang met een minimale tekstrequest. Test daarna afzonderlijk reasoning-velden, streaming-chunks, tool-calluitvoering en eventuele mediaformaten. Inspecteer fouten en antwoordkwaliteit: een HTTP 400 kan meerdere oorzaken hebben, terwijl een succesvolle HTTP-respons op zich geen capability-ondersteuning bewijst. Registreer geretourneerde usage en vergelijk de kosten met je budget. Houd base URL en model configureerbaar zodat je kunt terugvallen.
Configureer een omgevingsgestuurde migratie en rollback.
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":"Beoordeel dit API-ontwerp."}],
)
print(r.choices[0].message.content)
Begin met een kleine canary-fractie van live verkeer. Vergelijk juistheid, tool-succes, first-token-latentie, totale latentie, retry-rate en totale kosten per succesvol voltooide taak voordat je de uitrol vergroot.
Add Timeouts, Retry Limits and Monitoring
Stel request-timeouts en expliciete limieten in; log niet-gevoelige request-ID’s en tokengebruik; redacteer waar mogelijk persoonsgegevens; probeer alleen tijdelijke fouten opnieuw; en vereis autorisatie voor onomkeerbare toolacties. Een goedkopere modelaanroep is niet per se een goedkopere taak als deze retries veroorzaakt.
Probeer tijdelijke fouten opnieuw met begrensde exponentiële 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))
Aanbevolen operationele metriek: kosten per geslaagde taak = totale model- en toolkosten / aantal geslaagde taken. Volg zowel safety- en correctheids-guardrails als aggregaatkosten.
FAQ
Why can Muse Wonder API stop before its final answer?
Reasoning en zichtbare tekst delen een completionbudget op de native API. Een lange reasoning-pass kan minder ruimte overlaten voor het eindantwoord. Controleer de beëindigingsreden en usage, verlaag de inspanning of beperk de taak, en verhoog de door de route ondersteunde limiet voor de completion alleen binnen je budget. Een onderbroken stream vereist een afzonderlijke diagnose van de transportlaag.
Should I retry a Muse Wonder API stream from the beginning?
Een nieuwe request is een nieuwe generatie, geen automatische voortzetting van het onderbroken antwoord. Sla gedeeltelijke output en de request-ID op, markeer het antwoord als onvolledig en beslis of je opnieuw start of om een vervolg vraagt met expliciete context. Bewaar voor tool-workflows voltooide acties zodat een retry ze niet tweemaal uitvoert.
How do I validate Muse Wonder API media answers?
Gebruik een kleine testafbeelding of -document met bekende feiten en stel vragen waarvan de antwoorden die feiten vereisen. Vergelijk de respons met het origineel, inclusief nummers en paginareferenties. Een succesvolle HTTP-status bewijst op zich niet dat het endpoint de media correct heeft geaccepteerd of geïnterpreteerd; inspecteer fouten en requestformaten voordat je de inname opschaalt.
How can I audit a Muse Wonder API cost discrepancy?
Registreer geretourneerde usage, model, route, requesttijd en het accounttarief op dat moment. Splits niet-gecachete input, geverifieerde cache-reads en totaal gefactureerde output, inclusief reasoning waar van toepassing. Vergelijk die waarden met de facturatie; controleer valuta, tariefwijzigingen en extra kosten voordat je uitgaat van een fout in tokenboekhouding.
Conclusion
Begin met één geauthenticeerde CometAPI-request, bevestig het geretourneerde antwoord en voeg daarna streaming en de capabilities toe die je toepassing nodig heeft. Verifieer vóór productie-uitrol de geselecteerde route, bevestig facturatie, handhaaf toolpermissies en houd een rollback-model achter de hand. Breid verkeer pas uit als gemeten taaksucces, latentie en kosten voldoen aan je acceptatiecriteria.
