qwen-audio-3.0-realtime-plus

Élő hangalapú párbeszédre szolgáló modell, amely beszédet és szöveget fogad, és hanggal vagy szöveggel válaszol. Természetes beszélgetési tempóra és eszközökkel való együttműködésre tervezték.

Ailoot · Valós idejű hang GET /v1/realtime?model=qwen-audio-3.0-realtime-plus qwen-audio-3.0-realtime-plus

A modellről

Ez a leírás a modell képességeit ismerteti. Az Ailootban elérhető bemenetek, kimenetek és lehetőségek alább, a kiválasztott metódusnál láthatók.

A Qwen-Audio-3.0-Realtime-Plus az Alibaba modellje élő hangalapú párbeszédhez. Beszédet és szöveget fogad, hanggal és szöveggel válaszol, és természetes megszólalásváltással támogatja a kétirányú beszélgetést. A hang részletekben küldhető és fogadható, így az interakció a beszélgetés közben folyamatosan alakul.

Mikor fejezte be a beszélő a gondolatát?

Többféleképpen határozható meg egy megszólalás határa: hangaktivitás alapján, a gondolat teljessége szerint vagy kifejezett vezérléssel. A gyártónál a módot az első hangadat elküldése előtt kell kiválasztani; a beszélgetés megkezdése utáni módosításhoz új kapcsolat szükséges. E vezérlés támogatása a választott metódustól függ. A jelentésalapú mód figyelembe veszi a szüneteket és a töltelékszavakat: egy rövid megtorpanás nem feltétlenül jelenti azt, hogy a felhasználó befejezte a gondolatát. A felhasználó új megszólalása megszakíthatja a készülő választ, hogy a beszélgetés a következő hozzászólás figyelembevételével folytatódjon. A jelentésalapú módban a felismerés a kiválasztott beszélő hangmintájához igazítható, így kevésbé zavarják mások hangjai és a háttérzaj.

Az utasítások határozzák meg az asszisztens szerepét és a kommunikáció stílusát. A megszólalás figyelembe veheti a hangszínt, a tempót és az érzelmeket; a 3.0 verzió öt rendszerhangot és hangminta alapján készített hangokat kínál. A modell 11 nyelvet támogat, köztük az oroszt, valamint a gyártó által megjelölt kínai dialektusváltozatokat. A gyártónál a hangot a munkamenet beállításainak első frissítésekor kell megadni; ugyanabban a beszélgetésben egy később küldött új hang figyelmen kívül marad. E beállításokhoz a választott hozzáférési mód támogatása szükséges.

Eszközök és beszélgetési előzmények

A függvényhívás támogatott. A modell megfogalmazza a szükséges műveletet, a csatlakoztatott alkalmazás végrehajtja, és visszaadja az eredményt a párbeszédbe. Így a beszélgetés tényleges adatokra épülhet, és a művelet elvégzése után folytatódhat. A hangasszisztens az eszközök eredményeire támaszkodhat, miközben megőrzi a beszélgetés kontextusát. A gyártó képességei közé tartozik a beépített webes keresés is, ha azt a választott metódus biztosítja. A webes keresés és a függvényhívások egy munkamenetben nem kapcsolhatók be egyszerre.

Az előzmények alapértelmezés szerint 20 beszélgetési kört tartalmaznak, a megengedett tartomány egytől 50-ig terjed. A felhalmozott hanganyag korlátja 300 másodperc; a korlátok túllépésekor az előzmények régi részei törlődnek. Ez eltér az egyes megszólalások hosszától: az előzmények szabják meg, hogy a korábbi anyagból mi marad elérhető a párbeszéd folytatásakor.

Szöveges kontextus és hang

A formális kontextus 40 960 token. A bemenet maximális hossza 16 384 token, a kimeneté 8192; ugyanezek a bemeneti és kimeneti korlátok érvényesek a következtetési módra is, a gondolatmenet külön 1024 tokenes korlátjával.

A streamelt hanghoz egycsatornás, 16 bites PCM használható: a bemeneten 16 kHz, a kimeneten 24 kHz mintavétellel. A szöveges és a hangadatok egy beszélgetéshez tartoznak. Ennél a konkrét modellnél nincs feltüntetve vizuális bemenet vagy képkimenet; szakterülete a beszéd, a szöveg és a hangalapú interakció.

Ailoot · Valós idejű hang GET /v1/realtime?model=qwen-audio-3.0-realtime-plus qwen-audio-3.0-realtime-plus

qwen-audio-3.0-realtime-plus

Alibaba /qwen-audio-3.0-realtime-plus

Kezdő lépések

Elfogadott bemenetek: Szöveg · Hang
Eredmények: Szöveg · Hang

Elérhető az Ailootban · bemenetek és metódusok

Ailoot · Valós idejű hang GET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Bemenet: text, audio
Kimenet: text, audio
Kimeneti formátum: munkamenetesemények

Mező	Típus	Követelmény	Értékek és korlátok	Alapértelmezett
Mező`query.model`	Típus`string`	KövetelményKötelező	Értékek és korlátok qwen-audio-3.0-realtime-plus	Alapértelmezett—
Mező`session.input_audio_format`	Típus`string`	KövetelményOpcionális	Értékek és korlátok pcm16, pcm	Alapértelmezett—
Mező`session.output_audio_format`	Típus`string`	KövetelményOpcionális	Értékek és korlátok pcm16, pcm	Alapértelmezett—
Mező`session.instructions`	Típus`string`	KövetelményOpcionális	Értékek és korlátok A korlát erre vonatkozik: a kiválasztott munkamenet szabályzata	Alapértelmezett—
Mező`session.max_history_turns`	Típus`integer`	KövetelményOpcionális	Értékek és korlátok Minimum: 1 A korlát erre vonatkozik: a kiválasztott munkamenet szabályzata	Alapértelmezett—
Mező`input_audio_buffer.append.audio`	Típus`base64_string`	KövetelményKötelező	Értékek és korlátok Bemeneti tartalom: PCM16 monó; 16 kHz bemenet, 24 kHz kimenet; nem üres, páros bájthossz	Alapértelmezett—

Bemeneti anyagok kombinációi

realtime_text_audio

Metódus paraméterei és életciklusa

Paraméter	Szerződés
Paraméter`material_types`	Szerződéstext, audio
Paraméter`required`	Szerződésnull
Paraméter`optional_controls`	Szerződésnull
Paraméter`content_type`	SzerződésWebSocket

Életciklus: exact retained published method

A metódusok szerkezete és azonosítói pontosak; a beszállítói képesség különbözik a kérelmek befogadásától.

Díjcsomagok

Ailoot-metódusok díjai

Ailoot Valós idejű hangGET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Bemenet: 0,0008 USD / 1K
Kimenet: 0,0064 USD / 1K
Bemenet: 0,0048 USD hangpercenként
Kimenet: 0,018 USD kimeneti hangpercenként

Az Ailoot a kérés előtt becsült összeget foglal le. Az eredmény után a mért használat alapján elszámolja a végső díjat. Folyamatos átvitel esetén a végső használati rekordot használja. A foglalás és az elszámolás működése →

Példakérések

Ailoot · Valós idejű hang

Python WebSocket · szövegPython WebSocket · hang

# Install the documented client once: python3 -m pip install websockets
import base64, json, os, time, wave
from pathlib import Path
from websockets.sync.client import connect

key = os.environ.get("AILOOT_API_KEY", "")
if not key.strip():
    raise SystemExit("Set your AILOOT_API_KEY before connecting")
file = Path(os.environ.get("AILOOT_TEXT_FILE", ""))
if not file.is_file(): raise SystemExit("Set AILOOT_TEXT_FILE to your actual UTF-8 material")
material = file.read_text(encoding="utf-8")
if not material.strip(): raise SystemExit("Text material must not be empty")
out = Path("realtime-results")
out.mkdir(exist_ok=True)
audio, texts, complete = {}, {}, []
current_response = None
pending = False
deadline = time.monotonic() + 570  # Local client bound; lower server/session limits still apply.

def receive(ws, log):
    global current_response, pending
    left = deadline - time.monotonic()
    if left <= 0:
        raise TimeoutError("Client session limit; preserve IDs and partial results, do not replay")
    event = json.loads(ws.recv(timeout=min(60, left)))
    log.write(json.dumps(event, ensure_ascii=False) + "\n")
    log.flush()
    kind = event.get("type")
    if kind == "error":
        raise RuntimeError(json.dumps(event, ensure_ascii=False))
    if kind == "response.created":
        current_response = event["response"]["id"]
    if kind in {"response.audio.delta", "response.output_audio.delta", "response.text.delta", "response.output_text.delta", "response.audio_transcript.delta", "response.output_audio_transcript.delta", "response.text.done", "response.audio_transcript.done"}:
        identity = (event["response_id"], event["item_id"], event["output_index"], event["content_index"])
        if kind in {"response.audio.delta", "response.output_audio.delta"}:
            raw = base64.b64decode(event["delta"], validate=True)
            if len(raw) % 2: raise ValueError("Output PCM16 chunk must have an even byte length")
            audio.setdefault(identity, bytearray()).extend(raw)
        elif kind.endswith(".done"):
            texts[identity] = event.get("text", event.get("transcript", ""))
        else:
            texts[identity] = texts.get(identity, "") + event["delta"]
            print(event["delta"], end="", flush=True)
    if kind == "response.done":
        response = event["response"]
        complete.append(response)
        if current_response is None: current_response = response["id"]
        if response["id"] == current_response: pending = False
    return event

def wait_for(ws, log, kind):
    while True:
        event = receive(ws, log)
        if event.get("type") == kind: return event

def send(ws, event):
    ws.send(json.dumps(event, ensure_ascii=False))

try:
    # One exact model query; no reconnect/retry loop and no provider credentials.
    with connect("wss://api.ailoot.ai/v1/realtime?model=qwen-audio-3.0-realtime-plus", additional_headers={"Authorization": "Bearer " + key}) as ws:
        with (out / "events.jsonl").open("w", encoding="utf-8") as log:
            wait_for(ws, log, "session.created")
            send(ws, {"type":"session.update", "session":{"modalities":["audio","text"], "input_audio_format":"pcm", "output_audio_format":"pcm", "turn_detection":None}})
            wait_for(ws, log, "session.updated")
            send(ws, {"type":"conversation.item.create", "item":{"type":"message", "role":"user", "content":[{"type":"input_text", "text":material}]}})
            send(ws, {"type":"response.create"})
            pending = True
            try:
                while pending: receive(ws, log)
            except KeyboardInterrupt:
                # Cancel the actual current inference, then preserve its returned status.
                send(ws, {"type":"response.cancel"})
                while pending: receive(ws, log)
    if not complete or complete[-1].get("status") != "completed":
        raise RuntimeError("Response did not complete normally; inspect saved events and status")
finally:
    manifest = {"responses":complete, "parts":[]}
    for number, identity in enumerate(dict.fromkeys(list(audio) + list(texts))):
        record = {"response_id":identity[0], "item_id":identity[1], "output_index":identity[2], "content_index":identity[3]}
        if identity in audio:
            raw = bytes(audio[identity])
            pcm_file = out / ("audio-" + str(number) + ".pcm")
            wav_file = out / ("audio-" + str(number) + ".wav")
            pcm_file.write_bytes(raw)
            with wave.open(str(wav_file), "wb") as wav:
                wav.setnchannels(1); wav.setsampwidth(2); wav.setframerate(24000); wav.writeframes(raw)
            record.update({"pcm":str(pcm_file), "wav":str(wav_file), "sample_rate_hz":24000})
        if identity in texts:
            text_file = out / ("text-" + str(number) + ".txt")
            text_file.write_text(texts[identity], encoding="utf-8")
            record["text"] = str(text_file)
        manifest["parts"].append(record)
    (out / "results.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
    print("\nSaved every received event and result in", out)

# Install the documented client once: python3 -m pip install websockets
import base64, json, os, time, wave
from pathlib import Path
from websockets.sync.client import connect

key = os.environ.get("AILOOT_API_KEY", "")
if not key.strip():
    raise SystemExit("Set your AILOOT_API_KEY before connecting")
file = Path(os.environ.get("AILOOT_AUDIO_FILE", ""))
if not file.is_file(): raise SystemExit("Set AILOOT_AUDIO_FILE to your raw PCM16 mono 16-kHz recording")
material = file.read_bytes()
if not material or len(material) % 2 or material.startswith(b"RIFF"):
    raise SystemExit("Use nonempty signed little-endian PCM16 mono 16-kHz bytes, not a WAV header")
out = Path("realtime-results")
out.mkdir(exist_ok=True)
audio, texts, complete = {}, {}, []
current_response = None
pending = False
deadline = time.monotonic() + 570  # Local client bound; lower server/session limits still apply.

def receive(ws, log):
    global current_response, pending
    left = deadline - time.monotonic()
    if left <= 0:
        raise TimeoutError("Client session limit; preserve IDs and partial results, do not replay")
    event = json.loads(ws.recv(timeout=min(60, left)))
    log.write(json.dumps(event, ensure_ascii=False) + "\n")
    log.flush()
    kind = event.get("type")
    if kind == "error":
        raise RuntimeError(json.dumps(event, ensure_ascii=False))
    if kind == "response.created":
        current_response = event["response"]["id"]
    if kind in {"response.audio.delta", "response.output_audio.delta", "response.text.delta", "response.output_text.delta", "response.audio_transcript.delta", "response.output_audio_transcript.delta", "response.text.done", "response.audio_transcript.done"}:
        identity = (event["response_id"], event["item_id"], event["output_index"], event["content_index"])
        if kind in {"response.audio.delta", "response.output_audio.delta"}:
            raw = base64.b64decode(event["delta"], validate=True)
            if len(raw) % 2: raise ValueError("Output PCM16 chunk must have an even byte length")
            audio.setdefault(identity, bytearray()).extend(raw)
        elif kind.endswith(".done"):
            texts[identity] = event.get("text", event.get("transcript", ""))
        else:
            texts[identity] = texts.get(identity, "") + event["delta"]
            print(event["delta"], end="", flush=True)
    if kind == "response.done":
        response = event["response"]
        complete.append(response)
        if current_response is None: current_response = response["id"]
        if response["id"] == current_response: pending = False
    return event

def wait_for(ws, log, kind):
    while True:
        event = receive(ws, log)
        if event.get("type") == kind: return event

def send(ws, event):
    ws.send(json.dumps(event, ensure_ascii=False))

try:
    # One exact model query; no reconnect/retry loop and no provider credentials.
    with connect("wss://api.ailoot.ai/v1/realtime?model=qwen-audio-3.0-realtime-plus", additional_headers={"Authorization": "Bearer " + key}) as ws:
        with (out / "events.jsonl").open("w", encoding="utf-8") as log:
            wait_for(ws, log, "session.created")
            send(ws, {"type":"session.update", "session":{"modalities":["audio","text"], "input_audio_format":"pcm", "output_audio_format":"pcm", "turn_detection":None}})
            wait_for(ws, log, "session.updated")
            for offset in range(0, len(material), 640):
                send(ws, {"type":"input_audio_buffer.append", "audio":base64.b64encode(material[offset:offset+640]).decode("ascii")})
                time.sleep(0.02)
            send(ws, {"type":"input_audio_buffer.commit"})
            wait_for(ws, log, "input_audio_buffer.committed")
            send(ws, {"type":"response.create"})
            pending = True
            try:
                while pending: receive(ws, log)
            except KeyboardInterrupt:
                # Cancel the actual current inference, then preserve its returned status.
                send(ws, {"type":"response.cancel"})
                while pending: receive(ws, log)
    if not complete or complete[-1].get("status") != "completed":
        raise RuntimeError("Response did not complete normally; inspect saved events and status")
finally:
    manifest = {"responses":complete, "parts":[]}
    for number, identity in enumerate(dict.fromkeys(list(audio) + list(texts))):
        record = {"response_id":identity[0], "item_id":identity[1], "output_index":identity[2], "content_index":identity[3]}
        if identity in audio:
            raw = bytes(audio[identity])
            pcm_file = out / ("audio-" + str(number) + ".pcm")
            wav_file = out / ("audio-" + str(number) + ".wav")
            pcm_file.write_bytes(raw)
            with wave.open(str(wav_file), "wb") as wav:
                wav.setnchannels(1); wav.setsampwidth(2); wav.setframerate(24000); wav.writeframes(raw)
            record.update({"pcm":str(pcm_file), "wav":str(wav_file), "sample_rate_hz":24000})
        if identity in texts:
            text_file = out / ("text-" + str(number) + ".txt")
            text_file.write_text(texts[identity], encoding="utf-8")
            record["text"] = str(text_file)
        manifest["parts"].append(record)
    (out / "results.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
    print("\nSaved every received event and result in", out)

Eredmények fogadása és mentése

Ailoot · Valós idejű hang

munkamenetesemények

Őrizzen meg minden elkészült eredményt

Őrizzen meg minden teljes visszaadott választ, fájlt és tartalomrészt.

Állítsa össze az összes visszaadott hangdeltát és szöveg- vagy eseményeredményt minden tényleges válaszazonosítóhoz.

Ha az eredeti választ ellenőrizni kell

Őrizze meg a tényleges munkamenet-, válasz- és eseményazonosítókat, valamint a bizonylatokat.

Hibák és következő lépések

Válasz	Feltétel	Következő lépés
Válasz426 · `invalid_request_error`	FeltételNincs WebSocket protokollra váltás	Következő lépésHasználjon WebSocket-klienst Upgrade: websocket fejléccel.

Álnevek

Modell álnevei

Ailoot qwen-audio-3.0-realtime-plus

Metódusútvonalak álnevei

Használja a fent látható metódusútvonalakat.

Kapcsolódó modellazonosítók

qwen-audio-3.0-realtime-plus

FAQ · qwen-audio-3.0-realtime-plus

Milyen bemenetek és eredmények érhetők el?: GET /v1/realtime?model=qwen-audio-3.0-realtime-plus · qwen-audio-3.0-realtime-plus: text, audio → text, audio
Milyen korlátok érvényesek?: GET /v1/realtime?model=qwen-audio-3.0-realtime-plus · qwen-audio-3.0-realtime-plus: session.max_history_turns.minimum: 1

qwen-audio-3.0-realtime-plus