Jak korzystać z Muse Wonder API: Python, streaming i cennik

TL;DR

Muse Wonder to zapoznawczy model Meta do złożonego programowania, rozumowania i agentowych przepływów pracy. Deweloperzy mogą uzyskać dostęp do Muse Wonder API w CometAPI za pomocą klienta zgodnego z OpenAI i model="muse-wonder". Ten przewodnik pomaga deweloperom zaznajomionym z Pythonem lub JavaScriptem wysłać pierwsze żądanie, dodać strumieniowanie oraz ocenić rozumowanie, multimedia i koszty. W porównaniu z Muse Spark praktycznym powodem do oceny Wonder jest jego potencjał do bardziej niezawodnego wykonywania trudnych zadań; samo duże okno kontekstu nie jest powodem do migracji.

Kluczowe wnioski

• Integracja: użyj klucza API po stronie backendu, https://api.cometapi.com/v1, oraz model="muse-wonder".
• Pojemność: Muse Wonder ma okno kontekstu 1,048,576 tokenów; przytnij powtarzający się kontekst, aby kontrolować koszty.
• Możliwości: oceń osobno strumieniowanie, wywołania narzędzi i multimedia na wybranej trasie bramki.
• Rozumowanie: natywny Muse Wonder obsługuje od minimal do max; wyższy wysiłek zwiększa użycie tokenów i opóźnienia.
• Wdrożenie: porównaj wyniki na realnych zadaniach, zweryfikuj bieżące rozliczenia i zachowaj model do wycofania przed zwiększeniem ruchu.

Czym jest Muse Wonder API?

Meta wprowadziła Muse Wonder 12 października 2026 r. Model jest dostępny w wersji zapoznawczej przez Meta Model API do złożonego programowania, rozumowania i przepływów pracy opartych na narzędziach. CometAPI używa identyfikatora modelu muse-wonder; natywny identyfikator Meta to muse-wonder-1.0.

Natywny model koncentruje się na długotrwałym rozumowaniu, programowaniu i pracy z narzędziami. Aplikacje nadal dostarczają narzędzia, trwały stan, warunki zatrzymania i kontrole uprawnień; pojedyncze wywołanie modelu nie tworzy autonomicznego środowiska wykonawczego.

Specyfikacje Muse Wonder API

Muse Wonder vs Muse Wonder Full

Muse Wonder jest dostępny przez Meta Model API; Muse Wonder Full jest dostępny tylko w subskrypcjach Power Usage i Maximum Usage w Muse Code, a ustawienie reasoning_effort na max nie przełącza na Muse Wonder Full. Zobacz ogłoszenie premiery Meta.

Muse Spark API vs Muse Wonder API

Wybieraj między modelami na podstawie mierzonej skuteczności zadań i kosztów. Natywny przewodnik po modelu zaleca Wonder do złożonej pracy, a Spark do obciążeń wrażliwych na koszty; oba mają okno kontekstu 1,048,576 tokenów. Porównuj konkretną wersję Spark zamiast zakładać, że wszystkie wersje mają identyczne możliwości.

Muse Spark lepiej nadaje się do obciążeń wrażliwych na koszty; Muse Wonder jest ukierunkowany na złożone programowanie i długotrwałe rozumowanie. Zweryfikuj obsługę multimediów, sterowanie rozumowaniem i rozliczanie dla dokładnej wersji modelu i trasy bramki. Zachowaj model, który spełnia Twoje docelowe wskaźniki skuteczności i kosztów.

Jak krok po kroku używać Muse Wonder API z CometAPI

Krok 1: Utwórz i zabezpiecz klucz CometAPI

Utwórz konto, wygeneruj klucz API po stronie backendu i nie umieszczaj go w kodzie przeglądarkowym ani publicznych repozytoriach. Postępuj zgodnie z dokumentacją integracji CometAPI dotyczącą uwierzytelniania. Te przykłady wymagają zasilonego lub uprawnionego konta, Pythona 3.10+ lub wspieranego środowiska Node.js LTS oraz wychodzącego dostępu HTTPS. Zapisz przykłady JavaScript jako pliki .mjs.

Ustaw klucz API w sesji Bash.

export COMETAPI_KEY="your_cometapi_api_key"

Ustaw klucz API w sesji PowerShell.

$env:COMETAPI_KEY="your_cometapi_api_key"

Krok 2: Skonfiguruj endpoint Muse Wonder

Krok 3: Wyślij pierwsze żądanie z cURL

Wyślij minimalne uwierzytelnione żądanie czatu.

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

Pomyślne żądanie bez strumieniowania powinno zwrócić choices[0].message.content. Sprawdź zwrócony model i usage, gdy są dostępne, i potwierdź, że tekst odpowiada Twojemu poleceniu. Błędy uwierzytelniania wymagają sprawdzenia poświadczeń; błąd nieprawidłowego modelu wymaga sprawdzenia dostępu do modelu. Przykłady ilustrują wzorce żądań i nie reprezentują zmierzonej latencji ani wyników benchmarków.

Krok 4: Wykonaj żądanie w Pythonie

Zainstaluj bibliotekę kliencką Pythona.

pip install --upgrade openai

Wyślij żądanie w Pythonie i sprawdź użycie tokenów.

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)

Krok 5: Użyj JavaScript lub Node.js

Zainstaluj bibliotekę kliencką JavaScript.

npm install openai

Wyślij żądanie w 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);

Jak strumieniować odpowiedzi Muse Wonder z CometAPI

Strumieniowanie zwraca przyrostowe fragmenty odpowiedzi poprzez zdarzenia wysyłane przez serwer. Poprawia postrzeganą responsywność, choć niekoniecznie łączny koszt ani czas zakończenia. Wyświetlaj tylko fragmenty zawierające treść oraz obsługuj przypadki przerwania i przekroczenia limitu czasu.

Przykład strumieniowania w Pythonie

Czytaj przyrostowe fragmenty odpowiedzi w Pythonie.

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

Przykład strumieniowania w JavaScript

Czytaj przyrostowe fragmenty odpowiedzi w Node.js.

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

Jakie poziomy wysiłku rozumowania obsługuje Muse Wonder?

Obsługiwane wartości wysiłku rozumowania

Natywny model akceptuje minimal, low, medium, high, xhigh i max; żaden z nich nie jest nieobsługiwany. Zacznij od umiarkowanego ustawienia i podnoś je tylko wtedy, gdy Twoje ewaluacje uzasadniają dodatkowe opóźnienie i koszt tokenów wyjściowych. Zobacz odniesienie do rozumowania Meta. Przetestuj przekazywanie przez bramkę osobno.

Jak ustawić wysiłek rozumowania w Chat Completions

Poniższy przykład wysyła high przez bramkę jako test możliwości. Jeśli odrzucone, sprawdź błąd przed usunięciem pola: kod 400 może również wskazywać na nieprawidłowe wiadomości, błędny model lub inny problem z żądaniem. Spróbuj ponownie z minimalnym żądaniem tekstowym, aby odizolować przyczynę.

Przetestuj wysoki wysiłek rozumowania na bramce.

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)

Jak ustawić wysiłek rozumowania w Responses API

Natywne Responses API Meta zagnieżdża to pole jako reasoning.effort i używa muse-wonder-1.0. Poniższy przykład używa poświadczeń Meta i natywnego endpointu; niezależnie potwierdź obsługę Responses, zanim zaadaptujesz to do 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)

Dlaczego max nie wybiera Muse Wonder Full

max zmienia budżet rozumowania wybranego modelu. Nie zmienia identyfikatora modelu ani nie daje dostępu do Full; rozróżnienie dostępu wyjaśniono we wprowadzeniu do modelu.

Jak Muse Wonder API może analizować obrazy i pliki PDF

Meta dokumentuje wejścia obraz, wideo, audio i PDF dla natywnego Wonder. Natywna obsługa multimediów w Meta nie gwarantuje, że CometAPI akceptuje ten sam schemat treści, format URL, typy plików lub limity rozmiaru. Zweryfikuj te szczegóły na wybranej trasie przed użyciem produkcyjnym. Poniższy przykład image_url to wzorzec zgodności: użyj dostępnego obrazu, który kontrolujesz, potwierdź obsługę endpointu i sprawdź odpowiedź względem widocznych szczegółów.

Przetestuj URL obrazu z znanym obrazem.

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)

Dla przewidywalnego przepływu pracy wyłącznie tekstowego PDF wyodrębnij lokalnie tekst możliwy do zaznaczenia i wyślij wybrane fragmenty jako tekst. Nie testuje to natywnego wejścia PDF ani nie zachowuje układu stron, rysunków czy zeskanowanej treści. Przykład ogranicza wejście do 50 000 znaków na mały test; produkcyjne przetwarzanie powinno wybierać lub dzielić treść oraz zachowywać odniesienia do stron zamiast po cichu obcinać raport.

Wyodrębnij możliwy do zaznaczenia tekst PDF na potrzeby ograniczonego testu.

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

Jak zbudować agenta z wywołaniami narzędzi z Muse Wonder API

Model może poprosić o wywołanie funkcji, ale aplikacja musi je autoryzować i wykonać. Ten przykład demonstruje jedno ograniczone, tylko do odczytu zapytanie o status zamówienia; wdrożenia produkcyjne powinny weryfikować wejścia i ograniczać narzędzia uprawnieniami.

Wykonaj ograniczone żądanie narzędzia do statusu zamówienia.

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)

Ten przykład edukacyjny obsługuje jedną rundę wywołania narzędzia. Jeśli odpowiedź uzupełniająca poprosi o kolejne wywołanie narzędzia, kontynuuj tylko w ograniczonej pętli i ponownie zweryfikuj nazwę oraz argumenty. Utrwal wyniki narzędzi dla bezpieczeństwa ponowień; agent produkcyjny potrzebuje także limitu czasu, limitu iteracji oraz jasnego warunku zakończenia.

Ile kosztuje Muse Wonder API

Oficjalny cennik Meta podaje $4.00 za milion niebuforowanych tokenów wejściowych, $0.20 za milion buforowanych tokenów wejściowych oraz $20.00 za milion tokenów wyjściowych.

Migawka cen z artykułu źródłowego z 14 października 2026 r. podaje w CometAPI $3.20 za milion niebuforowanych tokenów wejściowych i $16.00 za milion tokenów wyjściowych. Są to stawki bramki, a nie zamiennik stawek Meta $4.00 za wejście i $20.00 za wyjście. Przed użyciem potwierdź bieżące stawki swojego konta i trasy; nie zakłada się taryfy dla buforowanego wejścia w CometAPI.

Dla 100,000 niebuforowanych tokenów wejściowych i 50,000 rozliczanych tokenów wyjściowych, podane stawki Meta dają $0.40 + $1.00 = $1.40. Podane stawki CometAPI dają $0.32 + $0.80 = $1.12. Ten przykład wyklucza dodatkowe opłaty i nie zakłada żadnej zniżki za cache.

W tym przykładzie bez cache wyświetlone stawki CometAPI dają o 20% niższy koszt szacunkowy. Rzeczywiste faktury zależą od użycia tokenów, rozliczania trasy i wszelkich dodatkowych opłat. Jeśli ma zastosowanie cache, oblicz go, używając zweryfikowanej taryfy cache zamiast stosować stawkę za niebuforowane wejście do każdego tokena.

Oszacuj koszt przy stawkach CometAPI z migawki źródłowej; zastąp je swoimi zweryfikowanymi stawkami konta.

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

Jak migrować i uruchamiać Muse Wonder w produkcji

Zaktualizuj i zweryfikuj integrację

Większość integracji z klientami zgodnymi z OpenAI może zachować swoją ogólną strukturę. Zaktualizuj bazowy URL, poświadczenia i identyfikator modelu, a następnie przeprowadź etapową ewaluację na rzeczywistych promptach. Specyficzne dla protokołu pola rozumowania i multimodalne wymagają niezależnej weryfikacji.

Ustaw COMETAPI_KEY, zaktualizuj bazowy URL do https://api.cometapi.com/v1 i wybierz muse-wonder. Zweryfikuj uwierzytelnienie i dostęp do modelu minimalnym żądaniem tekstowym. Następnie osobno przetestuj pola rozumowania, fragmenty strumieniowania, wykonanie wywołań narzędzi i każde formaty multimedialne. Sprawdzaj błędy i jakość odpowiedzi: HTTP 400 może mieć kilka przyczyn, a sam pomyślny status HTTP nie dowodzi obsługi danej możliwości. Rejestruj zwrócone usage i porównaj koszt z budżetem. Utrzymuj konfigurowalny bazowy URL i model, aby móc wrócić do poprzedniej wersji.

Skonfiguruj migrację i rollback sterowane środowiskiem.

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)

Zacznij od małej, kanarkowej (canary) części ruchu produkcyjnego. Porównaj poprawność, sukces wywołań narzędzi, opóźnienie pierwszego tokena, całkowite opóźnienie, odsetek ponowień i łączny koszt na pomyślnie zakończone zadanie przed rozszerzeniem wdrożenia.

Dodaj limity czasu, limity ponowień i monitorowanie

Ustaw limity czasu żądań i jawne ograniczenia; loguj niesensytywne identyfikatory żądań i użycie tokenów; anonimizuj dane osobowe, gdy to możliwe; ponawiaj tylko błędy przejściowe; oraz wymagaj autoryzacji dla nieodwracalnych działań narzędzi. Tańsze wywołanie modelu nie musi oznaczać tańszego zadania, jeśli powoduje ponowienia.

Ponawiaj błędy przejściowe z ograniczonym wykładniczym wycofywaniem.

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

Sugerowana metryka operacyjna: koszt na pomyślnie zakończone zadanie = łączny koszt modelu i narzędzi / liczba pomyślnie zakończonych zadań. Śledź ograniczenia bezpieczeństwa i poprawności oraz koszty zbiorcze.

FAQ

Dlaczego Muse Wonder API może zatrzymać się przed końcową odpowiedzią?

Rozumowanie i widoczny tekst dzielą budżet zakończenia w natywnym API. Długi przebieg rozumowania może pozostawić mniej miejsca na odpowiedź końcową. Sprawdź powód zakończenia i usage, zmniejsz wysiłek lub zawęź zadanie, a limit długości odpowiedzi obsługiwany przez trasę zwiększaj tylko w ramach budżetu. Przerwane strumieniowanie wymaga osobnej diagnostyki warstwy transportowej.

Czy powinienem ponowić strumień Muse Wonder API od początku?

Nowe żądanie to nowe generowanie, a nie automatyczna kontynuacja przerwanej odpowiedzi. Zapisz częściową odpowiedź i identyfikator żądania, oznacz odpowiedź jako niekompletną i zdecyduj, czy uruchomić od nowa, czy poprosić o kontynuację, używając jawnego kontekstu. W przepływach z narzędziami utrwal zakończone działania, aby ponowienie nie wykonało ich dwukrotnie.

Jak weryfikować odpowiedzi Muse Wonder API dla multimediów?

Użyj małego obrazu lub dokumentu o znanych faktach i zadawaj pytania, których odpowiedzi wymagają tych faktów. Porównaj odpowiedź z oryginałem, w tym liczby i odniesienia do stron. Sam pomyślny status HTTP nie dowodzi, że endpoint zaakceptował lub poprawnie zinterpretował multimedia; sprawdź błędy i formaty żądań, zanim zwiększysz skalę przetwarzania.

Jak mogę skontrolować rozbieżność kosztów Muse Wonder API?

Rejestruj zwrócone usage, model, trasę, czas żądania i stawkę konta w danym momencie. Rozdziel niebuforowane wejście, zweryfikowane odczyty z cache i łączne rozliczane wyjście, w tym rozumowanie, gdy dotyczy. Porównaj te wielkości z rekordem rozliczeniowym; sprawdź walutę, zmiany stawek i dodatkowe opłaty, zanim założysz błąd w rozliczaniu tokenów.

Wnioski

Zacznij od jednego uwierzytelnionego żądania do CometAPI, potwierdź zwróconą odpowiedź, a następnie dodaj strumieniowanie i możliwości potrzebne Twojej aplikacji. Przed wdrożeniem produkcyjnym zweryfikuj wybraną trasę, potwierdź rozliczenia, egzekwuj uprawnienia narzędzi i utrzymuj model do wycofania. Zwiększaj ruch tylko wtedy, gdy zmierzona skuteczność zadań, opóźnienia i koszty spełniają Twoje kryteria akceptacji.