Slik bruker du Muse Wonder API: Python, strømming og priser

TL;DR

Muse Wonder er Metas forhåndsvisningsmodell for kompleks koding, resonnering og agent-baserte arbeidsflyter. Utviklere kan få tilgang til Muse Wonder API i CometAPI med en OpenAI-kompatibel klient og model="muse-wonder". Denne veiledningen hjelper utviklere som er kjent med Python eller JavaScript med å sende en første forespørsel, legge til strømming og evaluere resonnering, medier og kostnad. Sammenlignet med Muse Spark er den praktiske grunnen til å evaluere Wonder modellens potensial til å fullføre vanskelige oppgaver mer pålitelig; et stort kontekstvindu alene er ikke en grunn til å migrere.

Key Takeaways

• Integrasjon: bruk en backend-API-nøkkel, https://api.cometapi.com/v1, og model="muse-wonder".
• Kapasitet: Muse Wonder har et kontekstvindu på 1,048,576-token; trim gjentatt kontekst for å kontrollere kostnaden.
• Kapabiliteter: evaluer strømming, verktøykall og medier separat på den valgte gateway-ruten.
• Resonnering: native Muse Wonder støtter minimal til max; høyere innsats øker tokenbruk og ventetid.
• Produksjonssetting: benchmark faktiske oppgaver, verifiser gjeldende fakturering, og bevar en tilbakeføringsmodell før du øker trafikken.

What Is Muse Wonder API?

Meta introduserte Muse Wonder 12. oktober 2026. Modellen er tilgjengelig i forhåndsvisning via Meta Model API for kompleks koding, resonnering og verktøydrevne arbeidsflyter. CometAPI bruker modellidentifikatoren muse-wonder; Metas native identifikator er muse-wonder-1.0.

Den native modellen fokuserer på vedvarende resonnering, koding og verktøydrevet arbeid. Applikasjoner må fortsatt levere verktøy, vedvarende tilstand, stoppbetingelser og tillatelseskontroller; et enkelt modellkall oppretter ikke et autonomt kjøremiljø.

Muse Wonder API specifications

Muse Wonder vs Muse Wonder Full

Muse Wonder er tilgjengelig via Meta Model API; Muse Wonder Full er kun tilgjengelig gjennom Power Usage- og Maximum Usage-abonnementene i Muse Code, og å sette reasoning_effort til max bytter ikke til Muse Wonder Full. Se Metas lanseringskunngjøring.

Muse Spark API vs Muse Wonder API

Velg mellom modellene basert på målt oppgavesuksess og kostnad. Den native modellveiledningen anbefaler Wonder for komplekst arbeid og Spark for kostnadssensitive arbeidslaster; begge har et kontekstvindu på 1,048,576-token. Sammenlign en spesifikk Spark-versjon i stedet for å anta at alle versjoner har identiske kapabiliteter.

Muse Spark passer bedre for kostnadssensitive arbeidslaster; Muse Wonder er rettet mot kompleks koding og vedvarende resonnering. Verifiser mediestøtte, resonneringskontroller og fakturering for nøyaktig modellversjon og gateway-rute. Behold modellen som oppfyller dine mål for målt oppgavesuksess og kostnad.

How to Use Muse Wonder API with CometAPI Step by Step

Step 1: Create and secure your CometAPI key

Opprett en konto, generer en backend-API-nøkkel, og hold den ute av nettleserkode og offentlige repositorier. Følg CometAPI-integrasjonsdokumentasjonen for autentisering. Disse eksemplene krever en finansiert eller kvalifisert konto, Python 3.10+ eller et støttet Node.js LTS-miljø, og utgående HTTPS-tilgang. Lagre JavaScript-eksempler som .mjs-filer.

Sett API-nøkkelen i en Bash-økt.

export COMETAPI_KEY="your_cometapi_api_key"

Sett API-nøkkelen i en PowerShell-økt.

$env:COMETAPI_KEY="your_cometapi_api_key"

Step 2: Configure the Muse Wonder endpoint

Step 3: Send your first request with cURL

Send en minimal autentisert chat-forespørsel.

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

En vellykket, ikke-strømmende forespørsel skal returnere choices[0].message.content. Inspiser den returnerte modellen og usage, når det leveres, og bekreft at teksten svarer på prompten din. Autentiseringsfeil krever legitimasjonskontroller; en ugyldig modellfeil krever tilgangskontroll for modellen. Eksemplene illustrerer forespørselmønstre og representerer ikke målt ventetid eller benchmark-resultater.

Step 4: Make a Python request

Installer Python-klientbiblioteket.

pip install --upgrade openai

Send en Python-forespørsel og inspiser tokenbruk.

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

Installer JavaScript-klientbiblioteket.

npm install openai

Send en Node.js-forespørsel.

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

Strømming returnerer inkrementelle svardeler over server-sent events. Det forbedrer opplevd responsivitet, men ikke nødvendigvis den totale kostnaden eller fullføringstiden. Vis kun deler som inneholder innhold, og håndter avbrudd og tidsavbruddstilfeller.

Python streaming example

Les inkrementelle Python-svardeler.

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

Les inkrementelle Node.js-svardeler.

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

Den native modellen aksepterer minimal, low, medium, high, xhigh og max; ingen er ikke støttet. Start med en moderat innstilling og øk den kun når evalueringene dine rettferdiggjør ekstra ventetid og kostnad i utdata-tokener. Se Metas resonneringsreferanse. Test gateway-videresending separat.

How to Set Reasoning Effort in Chat Completions

Følgende eksempel sender high via gatewayen som en kapabilitetstest. Hvis den avvises, inspiser feilen før du fjerner feltet: en 400 kan også indikere ugyldige meldinger, en feil modell eller et annet forespørselsproblem. Prøv igjen med den minimale tekstforespørselen for å isolere årsaken.

Test high reasoning effort 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": "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

Metas native Responses API nøster feltet som reasoning.effort og bruker muse-wonder-1.0. Eksemplet nedenfor bruker Meta-legitimasjon og dets native endepunkt; bekreft Responses-støtte uavhengig 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="Diagnose a distributed timeout.",
    reasoning={"effort": "high"},
)
print(response.output_text)

Why max Does Not Select Muse Wonder Full

max endrer resonneringsbudsjettet til den valgte modellen. Det endrer ikke modellidentifikatoren eller gir tilgang til Full; tilgangsskillet forklares i modellintroduksjonen.

How Can Muse Wonder API Analyze Images and PDFs

Meta dokumenterer bilde-, video-, lyd- og PDF-inndata for native Wonder. Metas native mediestøtte garanterer ikke at CometAPI aksepterer samme innholdsskjema, URL-format, filtyper eller størrelsesgrenser. Verifiser disse detaljene på den valgte ruten før produksjonsbruk. Eksempelet image_url nedenfor er et kompatibilitetsmønster: bruk et tilgjengelig bilde du kontrollerer, bekreft endepunktstøtte, og sjekk svaret mot synlige detaljer.

Test en bilde-URL med et kjent bilde.

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)

For en forutsigbar arbeidsflyt for kun tekst fra PDF, ekstraher valgbart tekstinnhold lokalt og send utvalgte avsnitt som tekst. Dette tester ikke native PDF-inndata eller bevarer sidelayout, figurer eller skannet innhold. Eksemplet begrenser inndata til 50,000 tegn for en liten test; produksjonsinntak bør velge eller dele opp innhold og bevare sidereferanser i stedet for å trunkere en rapport stille.

Ekstraher valgbart PDF-tekstinnhold for en avgrenset 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":
        "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

En modell kan be om et funksjonskall, men applikasjonen må autorisere og utføre det. Dette eksemplet demonstrerer ett avgrenset, skrivebeskyttet ordreoppslag; produksjonsimplementasjoner bør validere inndata og begrense verktøy etter tillatelse.

Kjør en avgrenset forespørsel om ordrestatus med verktøykall.

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)

Dette opplæringseksemplet håndterer én runde med verktøykall. Hvis oppfølgingssvar ber om et nytt verktøykall, fortsett kun innenfor en avgrenset løkke og valider navnet og argumentene på nytt. Persistér verktøyresultater for retry-sikkerhet; en produksjonsagent trenger også en tidsgrense, en iterasjonsgrense og en klar fullføringsbetingelse.

How Much Does Muse Wonder API Cost

Metas offisielle priser angir $4.00 per million ubufrede inndata-tokener, $0.20 per million bufrede inndata-tokener, og $20.00 per million utdata-tokener.

Kildeartikkelens pristabell 14. oktober 2026 viser CometAPI til $3.20 per million ubufrede inndata-tokener og $16.00 per million utdata-tokener. Dette er gateway-satser, ikke en erstatning for Metas $4.00 (inndata) og $20.00 (utdata). Bekreft dine gjeldende kontosatser og rutesatser før bruk; ingen CometAPI-tariff for bufrede inndata forutsettes.

For 100,000 ubufrede inndata-tokener og 50,000 fakturerte utdata-tokener gir de oppgitte Meta-satsene $0.40 + $1.00 = $1.40. De oppgitte CometAPI-satsene gir $0.32 + $0.80 = $1.12. Dette eksemplet ekskluderer ekstrakostnader og forutsetter ikke rabattert hurtigbuffer.

For dette ubufrede eksemplet gir de viste CometAPI-satsene et 20 % lavere estimat. Faktiske fakturaer avhenger av tokenbruk, rutefakturering og eventuelle tilleggskostnader. Hvis hurtigbuffer gjelder, beregn det med verifisert bufret tariff i stedet for å bruke ubufret inndata-sats på alle tokener.

Estimer kostnad med CometAPI-satsene i kildesnapshotet; erstatt dem med dine verifiserte kontosatser.

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 fleste OpenAI-kompatible klientintegrasjoner kan beholde sin overordnede struktur. Oppdater base-URL, legitimasjon og modell-ID, og kjør deretter en trinnvis evaluering på ekte prompt. Protokollspesifikke resonnerings- og multimodale felt trenger uavhengig verifisering.

Sett COMETAPI_KEY, oppdater base-URL til https://api.cometapi.com/v1 og velg muse-wonder. Verifiser autentisering og modelltilgang med en minimal tekstforespørsel. Test deretter resonneringsfelt, strømmedeler, verktøykall-utførelse og eventuelle mediaformater separat. Inspiser feil og svarkvalitet: en HTTP 400 kan ha flere årsaker, mens en vellykket HTTP-respons alene ikke beviser kapabilitetsstøtte. Registrer returnert usage og sammenlign kostnad med budsjettet ditt. Hold base-URL og modell konfigurerbar slik at du kan rulle tilbake.

Konfigurer en miljødrevet migrering og tilbakeføring.

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)

Start med en liten kanari-andel av live-trafikken. Sammenlign korrekthet, verktøysuksess, førstetoken-ventetid, total ventetid, retry-rate og total kostnad per vellykket fullført oppgave før du utvider utrullingen.

Add Timeouts, Retry Limits and Monitoring

Sett forespørsels-tidsavbrudd og eksplisitte grenser; logg ikke-sensitive forespørsels-ID-er og tokenbruk; fjern personopplysninger når mulig; prøv kun på nytt ved forbigående feil; og krev autorisasjon for irreversible verktøyhandlinger. Et billigere modellkall er ikke nødvendigvis en billigere oppgave hvis det forårsaker retries.

Gjør nye forsøk på forbigående feil med begrenset eksponentiell 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ått driftsmålepunkt: kostnad per vellykket oppgave = totale modell- og verktøykostnader / antall vellykkede oppgaver. Spor sikkerhets- og korrekthetsbeskyttelser så vel som samlede kostnader.

FAQ

Why can Muse Wonder API stop before its final answer?

Resonnering og synlig tekst deler et fullføringsbudsjett på den native API-en. En lang resonneringsfase kan gi mindre plass til det endelige svaret. Sjekk avslutningsårsak og usage, reduser innsats eller snevre inn oppgaven, og øk rute-støttet fullføringsgrense kun innenfor budsjettet ditt. En avbrutt strøm krever en separat transportdiagnose.

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

En ny forespørsel er en ny generering, ikke en automatisk fortsettelse av det avbrutte svaret. Lagre delvis utdata og forespørselsidentifikatoren, merk svaret som ufullstendig, og bestem om du vil starte på nytt eller be om en fortsettelse med eksplisitt kontekst. For verktøy-arbeidsflyter, persistér fullførte handlinger slik at en retry ikke kan utføre dem to ganger.

How do I validate Muse Wonder API media answers?

Bruk et lite testbilde eller dokument med kjente fakta og still spørsmål der svarene krever disse fakta. Sammenlign responsen med originalen, inkludert tall og sidereferanser. Vellykket HTTP-status alene beviser ikke at endepunktet aksepterte eller tolket mediet korrekt; inspiser feil og forespørselsformater før du skalerer inntaket.

How can I audit a Muse Wonder API cost discrepancy?

Registrer returnert usage, modell, rute, forespørselstid og kontosats på det tidspunktet. Skill mellom ubufrede inndata, verifiserte hurtigbuffer-lesinger og totalt fakturerte utdata, inkludert resonnering der det er aktuelt. Sammenlign disse størrelsene med faktureringsoppføringen; sjekk valuta, satsendringer og tilleggskostnader før du antar en feil i token-regnskapet.

Conclusion

Start med én autentisert CometAPI-forespørsel, bekreft det returnerte svaret, og legg deretter til strømming og kapabilitetene applikasjonen din trenger. Før produksjonsutrulling, valider den valgte ruten, verifiser fakturering, håndhev verktøytillatelser og behold en tilbakeføringsmodell. Øk trafikken først når målt oppgavesuksess, ventetid og kostnad møter akseptkriteriene dine.