Byg med CometAPIHar du brug for én API til flere modeller?Test workflowet i Playground, og opret derefter en API-nøgle, når model og pris passer til dit brugsscenarie.
Sådan bruger du Muse Wonder API: Python, streaming og priser
Lær at bruge Muse Wonder API med CometAPI. Følg Python- og JavaScript-eksempler på streaming, ræsonnering, multimodale input, prissætning og migrering.
Bobby SpencerForskningshold for AI-modeller og API
Muse Wonder er Metas preview-model til kompleks kodning, ræsonnering og agentiske arbejdsgange. Udviklere kan tilgå Muse Wonder API i CometAPI med en OpenAI-kompatibel klient og model="muse-wonder". Denne vejledning hjælper udviklere, der kender Python eller JavaScript, med at sende en første anmodning, tilføje streaming og evaluere ræsonnering, media og omkostninger. Sammenlignet med Muse Spark er den praktiske grund til at evaluere Wonder dets potentiale til at løse svære opgaver mere pålideligt; et stort kontekstvindue alene er ikke en grund til at migrere.
Key Takeaways
Integration: brug en backend-API-nøgle, https://api.cometapi.com/v1, og model="muse-wonder".
Kapacitet: Muse Wonder har et kontekstvindue på 1.048.576 tokens; trim gentagen kontekst for at styre omkostningerne.
Funktioner: evaluer streaming, værktøjskald og media separat på den valgte gateway-rute.
Gennemgået for klarhed, kildeangivelse og aktuel API-terminologi.
Ræsonnering: native Muse Wonder understøtter minimal til max; højere indsats øger tokenforbrug og latens.
Udrulning: benchmark virkelige opgaver, verificer aktuel fakturering, og bevar en rollback-model før udvidelse af trafikken.
What Is Muse Wonder API?
Meta introducerede Muse Wonder den 12. oktober 2026. Modellen er tilgængelig i preview gennem Meta Model API til kompleks kodning, ræsonnering og værktøjsdrevne arbejdsgange. CometAPI bruger modelidentifikatoren muse-wonder; Metas native identifikator er muse-wonder-1.0.
Den native model fokuserer på vedvarende ræsonnering, kodning og værktøjsdrevne opgaver. Applikationer leverer stadig værktøjer, persistent tilstand, stopbetingelser og tilladelseskontroller; et enkelt modelkald skaber ikke et autonomt eksekveringsmiljø.
Muse Wonder API specifications
Specifikation
Meta-modeldokumentation
Udvikler
Meta
Udgivelse
12. oktober 2026
Native Meta-identifikator
muse-wonder-1.0
CometAPI-identifikator
muse-wonder
Native kontekstvindue
1.048.576 tokens
Native input
Tekst, billede, video, lyd og PDF; gateway-formater kræver separat validering
Output
Tekst
Native API-status
Forhåndsvisning
Streaming og værktøjer
Native API-funktioner; valider den valgte CometAPI-rute
Full-varianten
Berettigede Muse Code-abonnementer; vælges ikke via ræsonneringsindsats
Muse Wonder vs Muse Wonder Full
Muse Wonder er tilgængelig via Meta Model API; Muse Wonder Full er kun tilgængelig via Power Usage- og Maximum Usage-abonnementerne i Muse Code, og at sætte reasoning_effort til max skifter ikke til Muse Wonder Full. Se Metas lanceringsmeddelelse: https://dev.meta.ai/resources/blog/build-with-muse-wonder
Muse Spark API vs Muse Wonder API
Vælg mellem modellerne ud fra målt opgavesucces og omkostninger. Den native modelvejledning anbefaler Wonder til komplekst arbejde og Spark til omkostningsfølsomme workloads; begge har et kontekstvindue på 1.048.576 tokens. Sammenlign en specifik Spark-version frem for at antage, at alle versioner har identiske evner.
Muse Spark er bedre egnet til omkostningsfølsomme workloads; Muse Wonder er målrettet kompleks kodning og vedvarende ræsonnering. Verificer mediesupport, ræsonneringskontroller og fakturering for den præcise modelversion og gateway-rute. Behold den model, der opfylder dine mål for målt opgavesucces og omkostninger.
How to Use Muse Wonder API with CometAPI Step by Step
Step 1: Create and secure your CometAPI key
Opret en konto, generer en backend-API-nøgle, og hold den ude af browserkode og offentlige repos. Følg CometAPI-integrationsdokumentationen for autentifikation: https://apidoc.cometapi.com/ Disse eksempler kræver en finansieret eller berettiget konto, Python 3.10+ eller et understøttet Node.js LTS-miljø og udgående HTTPS-adgang. Gem JavaScript-eksempler som .mjs-filer.
Angiv API-nøglen i en Bash-session.
export COMETAPI_KEY="your_cometapi_api_key"
Angiv API-nøglen i en PowerShell-session.
$env:COMETAPI_KEY="your_cometapi_api_key"
Step 2: Configure the Muse Wonder endpoint
Indstilling
Værdi
Basis-URL
https://api.cometapi.com/v1
Chat-endpoint
/chat/completions
HTTP-metode
POST
Godkendelse
Bearer API key
Model
muse-wonder
Step 3: Send your first request with cURL
Send en minimal, autentificeret chat-anmodning.
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": "Du er en senioringeniør."},
{"role": "user", "content": "Nævn tre måder at forbedre pålideligheden af Python-API'er."}
],
"stream": false
}'
En vellykket ikke-streaming-anmodning bør returnere choices[0].message.content. Inspicér den returnerede model og forbrug, når det angives, og bekræft, at teksten besvarer din prompt. Autentificeringsfejl kræver legitimationskontrol; en ugyldig model-fejl kræver kontrol af modeladgang. Eksemplerne illustrerer anmodningsmønstre og repræsenterer ikke målt latens eller benchmarkresultater.
Step 4: Make a Python request
Installer Python-klientbiblioteket.
pip install --upgrade openai
Send en Python-anmodning og inspicér tokenforbrug.
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": "Du er en Python-ingeniør."},
{"role": "user", "content": "Gennemgå: def divide(a,b): return a/b"},
],
)
print(response.choices[0].message.content)
if response.usage:
print("Samlet antal tokens:", response.usage.total_tokens)
Streaming returnerer inkrementelle svarstykker via server-sent events. Det forbedrer oplevet reaktionsevne, men ikke nødvendigvis den samlede omkostning eller gennemførselstid. Vis kun stykker, der indeholder indhold, og håndter afbrydelser og timeouts.
Python streaming example
Læs inkrementelle Python-svarstykker.
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 en skalerbar FastAPI-tjeneste."}],
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("\nSvar fuldført.")
JavaScript streaming example
Læs inkrementelle Node.js-svarstykker.
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: "Skitsér en forskningsagent."}],
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
Den native model accepterer minimal, low, medium, high, xhigh og max; ingen er ikke-understøttet. Start med en moderat indstilling og hæv den kun, når dine evalueringer retfærdiggør den ekstra latens og omkostning i output-tokens. Se Meta-ræsonneringsreferencen: https://dev.meta.ai/docs/reasoning Test gateway-forwarding separat.
How to Set Reasoning Effort in Chat Completions
Følgende eksempel sender high gennem gatewayen som en kapabilitetstest. Hvis det afvises, inspicér fejlen før du fjerner feltet: en 400 kan også indikere ugyldige beskeder, en forkert model eller et andet anmodningsproblem. Prøv igen med den minimale tekstanmodning for at isolere årsagen.
Test høj ræsonneringsindsats på gatewayen.
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": "Diagnosticér en distribueret timeout."}],
extra_body={"reasoning_effort": "high"},
)
print(response.choices[0].message.content)
except BadRequestError as err:
print("Denne ræsonneringsparameter accepteres muligvis ikke:", err)
How to Set Reasoning Effort in the Responses API
Metas native Responses API indlejrer feltet som reasoning.effort og bruger muse-wonder-1.0. Eksemplet nedenfor bruger Meta-legitimationsoplysninger og dets native endpoint; bekræft Responses-understøttelse uafhængigt, før du tilpasser det til 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="Diagnosticér en distribueret timeout.",
reasoning={"effort": "high"},
)
print(response.output_text)
Why max Does Not Select Muse Wonder Full
max ændrer ræsonneringsbudgettet for den valgte model. Det ændrer ikke modelidentifikatoren og giver ikke adgang til Full; adgangsforskellen forklares i modelintroduktionen.
How Can Muse Wonder API Analyze Images and PDFs
Meta dokumenterer billede-, video-, lyd- og PDF-input for native Wonder: https://dev.meta.ai/docs/models Metas native medieunderstøttelse garanterer ikke, at CometAPI accepterer samme indholdsskema, URL-format, filtyper eller størrelsesgrænser. Verificer disse detaljer på den valgte rute før produktion. Eksemplet image_url nedenfor er et kompatibilitetsmønster: brug et tilgængeligt billede, du kontrollerer, bekræft endpoint-understøttelse, og tjek svaret mod synlige detaljer.
Test en billede-URL med et kendt billede.
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": "Beskriv afvigelser i dette dashboard."},
{"type": "image_url", "image_url": {
"url": "https://example.com/dashboard.png"}},
]}],
)
print(response.choices[0].message.content)
For et forudsigeligt tekstkun-PDF-flow, udtræk selekterbar tekst lokalt og send udvalgte passager som tekst. Dette tester ikke native PDF-input eller bevarer sidelayout, figurer eller scannet indhold. Eksemplet begrænser input til 50.000 tegn til en lille test; produktionsindtag bør udvælge eller opdele indhold og bevare sidehenvisninger i stedet for at afkorte en rapport i stilhed.
Udtræk selekterbar PDF-tekst til en afgrænset 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":
"Opsummer risiciene i denne rapport:\n" + document_text[:50000]}],
)
print(response.choices[0].message.content)
How Can You Build a Tool-Calling Agent With Muse Wonder API
En model kan anmode om et funktionskald, men applikationen skal autorisere og udføre det. Dette eksempel demonstrerer et afgrænset, skrivebeskyttet ordreopslag; produktionsimplementeringer bør validere input og begrænse værktøjer efter tilladelser.
Udfør et afgrænset værktøjskald for ordrestatus.
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": "Slå en ordrestatus op",
"parameters": {"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"], "additionalProperties": False}
}}]
messages = [{"role": "user", "content": "Status for ordre 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": "Afsendt"}.get(args["order_id"], "Ikke fundet")
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)
Dette undervisningseksempel håndterer én runde af værktøjskald. Hvis opfølgende svar anmoder om endnu et værktøjskald, så fortsæt kun inden for en afgrænset løkke og validér igen navn og argumenter. Persister værktøjsresultater for genforsøgsrobusthed; en produktionsagent har også brug for en tidsgrænse, en iterationsgrænse og en klar afslutningsbetingelse.
Kildeartiklens prisoversigt pr. 14. oktober 2026 angiver CometAPI til $3.20 per million ikke-cachede input-tokens og $16.00 per million output-tokens. Dette er gateway-takster, ikke en erstatning for Metas $4.00 input- og $20.00 output-priser. Bekræft dine aktuelle kontotakster og rutepriser før brug; der antages ingen CometAPI-takst for cachet input.
Per 1M tokens
Meta native API
Muse Wonder API i CometAPI
Uncached input
$4.00
$3.20
Cached input
$0.20
Bekræft rute-takst
Output
$20.00
$16.00
For 100.000 ikke-cachede input-tokens og 50.000 fakturerede output-tokens giver de angivne Meta-takster $0.40 + $1.00 = $1.40. De angivne CometAPI-takster giver $0.32 + $0.80 = $1.12. Dette eksempel udelukker ekstra gebyrer og antager ingen cache-rabat.
For dette ikke-cachede eksempel giver de viste CometAPI-takster et 20% lavere estimat. Faktiske fakturaer afhænger af tokenforbrug, rutefakturering og eventuelle ekstra gebyrer. Hvis caching gælder, skal du beregne den med den bekræftede cachetakst i stedet for at anvende taksten for ikke-cachet input på alle tokens.
Estimér omkostning med CometAPI-taksterne i kildeoversigten; erstat dem med dine bekræftede kontotakster.
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('Antallet af tokens skal være ikke-negativt')
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 fleste OpenAI-kompatible klientintegrationer kan bevare deres overordnede struktur. Opdatér basis-URL, legitimationsoplysninger og model-ID, og kør derefter en trinvis evaluering på rigtige prompts. Ræsonnerings- og multimodale felter, der er specifikke for protokollen, skal valideres uafhængigt.
Sæt COMETAPI_KEY, opdatér basis-URL til https://api.cometapi.com/v1 og vælg muse-wonder. Verificér autentifikation og modeladgang med en minimal tekstanmodning. Test derefter ræsonneringsfelter, streaming-stykker, eksekvering af værktøjskald og eventuelle mediaformater separat. Inspicér fejl og svarkvalitet: en HTTP 400 kan have flere årsager, mens en vellykket HTTP-status alene ikke beviser funktionel understøttelse. Registrér returneret forbrug og sammenlign omkostninger med dit budget. Hold basis-URL og model konfigurerbare, så du kan rulle tilbage.
Konfigurér en miljøstyret migrering og 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":"Gennemgå dette API-design."}],
)
print(r.choices[0].message.content)
Start med en lille kanarie-fraktion af live-trafikken. Sammenlign korrekthed, værktøjssucces, første-token-latens, samlet latens, genforsøgsrate og samlede omkostninger per vellykket opgave før en bredere udrulning.
Add Timeouts, Retry Limits and Monitoring
Angiv anmodningstimeouts og eksplicitte grænser; log ikke-følsomme anmodnings-id’er og tokenforbrug; redigér personoplysninger, når det er muligt; genforsøg kun forbigående fejl; og kræv autorisation for irreversible værktøjsaktioner. Et billigere modelkald er ikke nødvendigvis en billigere opgave, hvis det medfører genforsøg.
Genforsøg forbigående fejl med begrænset eksponentiel 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))
Foreslået driftsmetrik: omkostning per vellykket opgave = samlede model- og værktøjsomkostninger / antal vellykkede opgaver. Spor sikkerheds- og korrekthedsgelændere såvel som samlede omkostninger.
FAQ
Why can Muse Wonder API stop before its final answer?
Ræsonnering og synlig tekst deler et fælles færdiggørelsesbudget på den native API. En lang ræsonneringsfase kan efterlade mindre plads til det endelige svar. Tjek afslutningsårsagen og forbrug, reducer indsatsen eller indsnævr opgaven, og øg kun den ruteunderstøttede completions-grænse inden for dit budget. En afbrudt stream kræver en separat transportdiagnose.
Should I retry a Muse Wonder API stream from the beginning?
En ny anmodning er en ny generering, ikke en automatisk fortsættelse af det afbrudte svar. Gem delvist output og anmodnings-id’et, markér svaret som ufuldstændigt, og beslut om du vil starte forfra eller bede om en fortsættelse med eksplicit kontekst. For værktøjsworkflows: persister fuldførte handlinger, så et genforsøg ikke kan udføre dem to gange.
How do I validate Muse Wonder API media answers?
Brug et lille testbillede eller dokument med kendte fakta, og stil spørgsmål, hvis svar kræver disse fakta. Sammenlign svaret med originalen, inkl. tal og sidehenvisninger. En vellykket HTTP-status beviser ikke alene, at endpointet accepterede eller fortolkede media korrekt; inspicér fejl og anmodningsformater før skalering af indtag.
How can I audit a Muse Wonder API cost discrepancy?
Registrér returneret forbrug, model, rute, anmodningstid og kontotakst på det tidspunkt. Adskil ikke-cachet input, verificerede cacheread og samlet faktureret output, inkl. ræsonnering hvor relevant. Sammenlign disse størrelser med fakturagrundlaget; tjek valuta, takstændringer og ekstra gebyrer, før du antager en fejl i tokenopgørelsen.
Conclusion
Start med én autentificeret CometAPI-anmodning, bekræft det returnerede svar, og tilføj dernæst streaming og de funktioner, din applikation har brug for. Før produktionsudrulning: valider den valgte rute, verificér fakturering, håndhæv værktøjstilladelser og behold en rollback-model. Udvid kun trafikken, når målt opgavesucces, latens og omkostninger opfylder dine acceptkriterier.
