qwen-audio-3.0-realtime-plus

Modell für Sprachdialoge in Echtzeit, das Sprache und Text entgegennimmt und mit Sprache oder Text antwortet. Ausgelegt auf ein natürliches Gesprächstempo und die Interaktion mit Werkzeugen.

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

Über das Modell

Diese Beschreibung erläutert die Fähigkeiten des Modells. Die über Ailoot verfügbaren Eingaben, Ausgaben und Optionen sind unten für die ausgewählte Methode aufgeführt.

Qwen-Audio-3.0-Realtime-Plus ist ein Modell von Alibaba für Sprachdialoge in Echtzeit. Es nimmt Sprache und Text entgegen, antwortet mit Audio und Text und unterstützt ein Gespräch in beide Richtungen mit natürlichem Wechsel der Gesprächsbeiträge. Audio kann abschnittsweise übertragen und empfangen werden, sodass sich die Interaktion während des Gesprächs entwickelt.

Wann ein Gesprächsbeitrag abgeschlossen ist

Es gibt mehrere Möglichkeiten, die Grenzen eines Gesprächsbeitrags zu erkennen: anhand der Sprachaktivität, der inhaltlichen Vollständigkeit oder durch ausdrückliche Steuerung. Beim Hersteller wird der Modus vor der Übertragung des ersten Audios gewählt; für eine Änderung nach Gesprächsbeginn ist eine neue Verbindung erforderlich. Ob diese Steuerung unterstützt wird, hängt von der gewählten Methode ab. Der semantische Modus berücksichtigt Pausen und Füllwörter: Ein kurzes Zögern bedeutet nicht zwangsläufig, dass der Nutzer seinen Gedanken abgeschlossen hat. Neue Nutzersprache kann die gerade erzeugte Antwort unterbrechen, damit das Gespräch unter Berücksichtigung des nächsten Beitrags weitergeht. Im semantischen Modus lässt sich die Erkennung an einer Sprachprobe des gewählten Gesprächspartners ausrichten, um fremde Stimmen und Hintergrundgeräusche weniger zu berücksichtigen.

Anweisungen bestimmen die Rolle des Assistenten und den Gesprächsstil. Die stimmliche Darstellung kann Ton, Tempo und Emotion berücksichtigen; für Version 3.0 sind fünf Systemstimmen sowie Stimmen nach einer Sprachprobe vorgesehen. Das Modell unterstützt 11 Sprachen, darunter Russisch, sowie die vom Hersteller genannten chinesischen Dialektvarianten. Beim Hersteller wird die Stimme bei der ersten Aktualisierung der Sitzungseinstellungen festgelegt; eine später übermittelte neue Stimme wird im selben Gespräch ignoriert. Diese Einstellungen benötigen Unterstützung durch die gewählte Zugriffsmethode.

Werkzeuge und Gesprächsverlauf

Funktionsaufrufe werden unterstützt. Das Modell formuliert die erforderliche Aktion, die verbundene Anwendung führt sie aus und gibt das Ergebnis an den Dialog zurück. So kann ein Gespräch auf tatsächlichen Daten aufbauen und nach einer ausgeführten Operation fortgesetzt werden. Der Sprachassistent kann Werkzeugergebnisse nutzen und dabei den Gesprächskontext beibehalten. Die Herstellerfunktionen umfassen ausserdem eine integrierte Websuche, sofern die gewählte Methode sie bereitstellt. Websuche und Funktionsaufrufe können nicht gleichzeitig in einer Sitzung aktiviert werden.

Standardmässig enthält der Verlauf 20 Gesprächsrunden; vorgesehen ist ein Bereich von einer bis 50. Für angesammeltes Audio gilt eine Grenze von 300 Sekunden; bei Überschreitung der Grenzen werden ältere Teile des Verlaufs entfernt. Das unterscheidet sich von der Dauer eines einzelnen Beitrags: Der Verlauf bestimmt, welches frühere Material bei der Fortsetzung des Dialogs verfügbar bleibt.

Textkontext und Audio

Der formale Kontext umfasst 40 960 Tokens. Die maximale Eingabelänge beträgt 16 384 Tokens, die Ausgabelänge 8192; dieselben Eingabe- und Ausgabegrenzen gelten für den Reasoning-Modus, mit einer separaten Grenze von 1024 Tokens für die Reasoning-Kette.

Für Audio-Streaming ist einkanaliges PCM mit 16-Bit-Darstellung vorgesehen: bei der Eingabe 16 kHz, bei der Ausgabe 24 kHz. Text- und Audiodaten gehören zu einem gemeinsamen Gespräch. Visuelle Eingabe und Bildausgabe sind für dieses konkrete Modell nicht angekündigt; sein Schwerpunkt liegt auf Sprache, Text und stimmlicher Interaktion.

Ailoot · Sprache in Echtzeit 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

Einstieg

Modell für Sprachdialoge in Echtzeit, das Sprache und Text entgegennimmt und mit Sprache oder Text antwortet. Ausgelegt auf ein natürliches Gesprächstempo und die Interaktion mit Werkzeugen.

Zulässige Eingaben: Text · Audio
Ergebnisse: Text · Audio

In Ailoot verfügbar · Eingaben und Methoden

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

Eingabe: text, audio
Ausgabe: text, audio
Ausgabeformat: Sitzungsereignisse

Feld	Typ	Anforderung	Werte und Limits	Standard
Feld`query.model`	Typ`string`	AnforderungErforderlich	Werte und Limits qwen-audio-3.0-realtime-plus	Standard—
Feld`session.input_audio_format`	Typ`string`	AnforderungOptional	Werte und Limits pcm16, pcm	Standard—
Feld`session.output_audio_format`	Typ`string`	AnforderungOptional	Werte und Limits pcm16, pcm	Standard—
Feld`session.instructions`	Typ`string`	AnforderungOptional	Werte und Limits Limit gilt für: Ausgewählte Sitzungsrichtlinie	Standard—
Feld`session.max_history_turns`	Typ`integer`	AnforderungOptional	Werte und Limits Minimum: 1 Limit gilt für: Ausgewählte Sitzungsrichtlinie	Standard—
Feld`input_audio_buffer.append.audio`	Typ`base64_string`	AnforderungErforderlich	Werte und Limits Eingabeinhalt: PCM16 mono; 16 kHz Eingabe, 24 kHz Ausgabe; nicht leere Daten mit gerader Bytelänge	Standard—

Kombinationen von Eingabematerialien

realtime_text_audio

Methodenparameter und Lebenszyklus

Parameter	Vertrag
Parameter`material_types`	Vertragtext, audio
Parameter`required`	Vertragnull
Parameter`optional_controls`	Vertragnull
Parameter`content_type`	VertragWebSocket

Lebenszyklus: exact retained published method

Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.

Tarife

Ailoot-Methodentarife

Ailoot Sprache in EchtzeitGET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Eingabe: $ 0.0008 / 1K
Ausgabe: $ 0.0064 / 1K
Eingabe: $ 0.0048 pro Minute Audio
Ausgabe: $ 0.018 pro Minute Ausgabeaudio

Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschliessenden Verbrauchsdatensatzes. So funktionieren Reservierung und Abrechnung →

Beispielanfragen

Ailoot · Sprache in Echtzeit

Python WebSocket · TextPython 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)

Ergebnisse abrufen und speichern

Ailoot · Sprache in Echtzeit

Sitzungsereignisse

Alle fertiggestellten Ergebnisse aufbewahren

Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.

Setzen Sie für jede tatsächliche Antwort-ID alle zurückgegebenen Audioteilstücke und Text-/Ereignisergebnisse zusammen.

Wenn die ursprüngliche Antwort geprüft werden muss

Bewahren Sie die tatsächlichen Sitzungs-, Antwort- und Ereignis-IDs sowie die Belege auf.

Fehler und nächste Schritte

Antwort	Bedingung	Nächster Schritt
Antwort426 · `invalid_request_error`	BedingungKeine Umstellung auf WebSocket	Nächster SchrittVerwenden Sie einen WebSocket-Client mit Upgrade: websocket.

Aliasnamen

Modellaliasnamen

Ailoot qwen-audio-3.0-realtime-plus

Aliasnamen für Methodenpfade

Verwenden Sie die oben angezeigten Methodenpfade.

Zugehörige Aufrufer-IDs

qwen-audio-3.0-realtime-plus

FAQ · qwen-audio-3.0-realtime-plus

Welche Eingaben und Ergebnisse sind verfügbar?: GET /v1/realtime?model=qwen-audio-3.0-realtime-plus · qwen-audio-3.0-realtime-plus: text, audio → text, audio
Welche Grenzen gelten?: 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