qwen-audio-3.0-realtime-plus

Een model voor live spraakgesprekken dat spraak en tekst accepteert en met stem of tekst antwoordt. Het is ontworpen voor een natuurlijk gesprekstempo en samenwerking met tools.

Ailoot · Spraak in realtime GET /v1/realtime?model=qwen-audio-3.0-realtime-plus qwen-audio-3.0-realtime-plus

Over het model

Deze beschrijving gaat over de mogelijkheden van het model. De via Ailoot beschikbare invoer, uitvoer en opties staan hieronder voor de geselecteerde methode.

Qwen-Audio-3.0-Realtime-Plus is een model van Alibaba voor live spraakgesprekken. Het accepteert spraak en tekst, antwoordt met audio en tekst en ondersteunt een gesprek in twee richtingen met een natuurlijke uitwisseling van uitspraken. Audio kan in delen worden verzonden en ontvangen, zodat de interactie zich tijdens het gesprek ontwikkelt.

Wanneer de gesprekspartner is uitgepraat

Er zijn meerdere manieren om het einde van een uitspraak te bepalen: via geluidsactiviteit, inhoudelijke afronding en expliciete besturing. Bij de fabrikant wordt de modus gekozen voordat de eerste audio wordt verzonden; wijzigen nadat het gesprek is begonnen vereist een nieuwe verbinding. Ondersteuning voor deze besturing hangt af van de gekozen methode. De semantische modus houdt rekening met pauzes en opvulwoorden: een korte aarzeling betekent niet noodzakelijk dat de gebruiker is uitgepraat. Nieuwe spraak van de gebruiker kan het antwoord dat wordt gegenereerd onderbreken, zodat het gesprek doorgaat met de volgende uitspraak in gedachten. In de semantische modus kan de herkenning worden gericht op een stemvoorbeeld van de gekozen gesprekspartner om minder te worden afgeleid door andere stemmen en achtergrondgeluid.

Instructies bepalen de rol van de assistent en de gespreksstijl. De stem kan rekening houden met toon, tempo en emotie; versie 3.0 biedt vijf systeemstemmen en stemmen op basis van een spraakvoorbeeld. Het model ondersteunt 11 talen, waaronder Russisch, en de Chinese dialectvarianten die de fabrikant noemt. Bij de fabrikant wordt de stem ingesteld bij de eerste update van de sessie-instellingen; een nieuwe stem die later in hetzelfde gesprek wordt doorgegeven, wordt genegeerd. Deze instellingen vereisen ondersteuning door de gekozen aanroepmethode.

Tools en gespreksgeschiedenis

Functieaanroepen worden ondersteund. Het model formuleert de gewenste actie, de gekoppelde toepassing voert die uit en geeft het resultaat terug in het gesprek. Zo kan een gesprek worden opgebouwd rond feitelijke gegevens en doorgaan nadat een handeling is uitgevoerd. De spraakassistent kan voortbouwen op toolresultaten met behoud van de gesprekscontext. De mogelijkheden van de fabrikant omvatten ook ingebouwd zoeken op het web, als de gekozen methode dit biedt. Zoeken op het web en functieaanroepen kunnen niet tegelijk in één sessie worden ingeschakeld.

De geschiedenis bevat standaard 20 gespreksbeurten, met een instelbaar bereik van één tot 50. Voor verzamelde audio geldt een grens van 300 seconden; oude delen van de geschiedenis worden verwijderd wanneer de grenzen worden overschreden. Dit verschilt van de duur van een afzonderlijke uitspraak: de geschiedenis bepaalt welk eerder materiaal beschikbaar blijft bij het voortzetten van het gesprek.

Tekstcontext en audio

De formele context is 40 960 tokens. De maximale invoerlengte is 16 384 tokens en de maximale uitvoerlengte 8192; dezelfde in- en uitvoergrenzen gelden voor de redeneermodus, met een afzonderlijke grens van 1024 tokens voor de redeneerketen.

Streaming audio gebruikt éénkanaals PCM met 16-bits representatie: 16 kHz voor invoer en 24 kHz voor uitvoer. Tekst- en audiogegevens horen bij hetzelfde gesprek. Voor dit specifieke model zijn visuele invoer en uitvoer van afbeeldingen niet aangekondigd; het is gespecialiseerd in spraak, tekst en gesproken interactie.

Ailoot · Spraak in realtime 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

Aan de slag

Een model voor live spraakgesprekken dat spraak en tekst accepteert en met stem of tekst antwoordt. Het is ontworpen voor een natuurlijk gesprekstempo en samenwerking met tools.

Toegestane invoer: Tekst · Audio
Resultaten: Tekst · Audio

Beschikbaar in Ailoot · invoer en methoden

Ailoot · Spraak in realtime GET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Invoer: text, audio
Uitvoer: text, audio
Uitvoerformaat: sessiegebeurtenissen

Veld	Type	Vereiste	Waarden en limieten	Standaard
Veld`query.model`	Type`string`	VereisteVereist	Waarden en limieten qwen-audio-3.0-realtime-plus	Standaard—
Veld`session.input_audio_format`	Type`string`	VereisteOptioneel	Waarden en limieten pcm16, pcm	Standaard—
Veld`session.output_audio_format`	Type`string`	VereisteOptioneel	Waarden en limieten pcm16, pcm	Standaard—
Veld`session.instructions`	Type`string`	VereisteOptioneel	Waarden en limieten Limiet geldt voor: geselecteerd sessiebeleid	Standaard—
Veld`session.max_history_turns`	Type`integer`	VereisteOptioneel	Waarden en limieten Minimum: 1 Limiet geldt voor: geselecteerd sessiebeleid	Standaard—
Veld`input_audio_buffer.append.audio`	Type`base64_string`	VereisteVereist	Waarden en limieten Invoerinhoud: PCM16 mono; 16 kHz invoer, 24 kHz uitvoer; niet-lege, even lengte in bytes	Standaard—

Combinaties van invoermaterialen

realtime_text_audio

Methodeparameters en levenscyclus

Parameter	Contract
Parameter`material_types`	Contracttext, audio
Parameter`required`	Contractnull
Parameter`optional_controls`	Contractnull
Parameter`content_type`	ContractWebSocket

Levenscyclus: exact retained published method

De methodestructuren en ID’s zijn exact; de mogelijkheden van de leverancier staan los van toelating.

Tarieven

Ailoot-methodetarieven

Ailoot Spraak in realtimeGET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Invoer: US$ 0,0008 / 1K
Uitvoer: US$ 0,0064 / 1K
Invoer: US$ 0,0048 per minuut audio
Uitvoer: US$ 0,018 per minuut audio-uitvoer

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. Zo werken reservering en afrekening →

Voorbeeldverzoeken

Ailoot · Spraak in realtime

Python WebSocket · tekstPython WebSocket · audio

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

Resultaten ophalen en opslaan

Ailoot · Spraak in realtime

sessiegebeurtenissen

Alle voltooide resultaten bewaren

Bewaar elk volledig teruggegeven antwoord, bestand en inhoudsonderdeel.

Voeg elke teruggestuurde audiodelta en elk tekst- of gebeurtenisresultaat samen per werkelijke antwoord-ID.

Als het oorspronkelijke antwoord moet worden gecontroleerd

Bewaar de werkelijke sessie-, antwoord- en gebeurtenis-ID's en bewijsstukken.

Fouten en vervolgstappen

Antwoord	Voorwaarde	Volgende stap
Antwoord426 · `invalid_request_error`	VoorwaardeGeen WebSocket-upgrade	Volgende stapGebruik een WebSocket-client met Upgrade: websocket.

Aliasnamen

Modelaliasnamen

Ailoot qwen-audio-3.0-realtime-plus

Aliasnamen voor methodepaden

Gebruik de hierboven getoonde methodepaden.

Gerelateerde aanroeper-ID’s

qwen-audio-3.0-realtime-plus

FAQ · qwen-audio-3.0-realtime-plus

Welke invoer en resultaten zijn beschikbaar?: GET /v1/realtime?model=qwen-audio-3.0-realtime-plus · qwen-audio-3.0-realtime-plus: text, audio → text, audio
Welke limieten gelden?: 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