qwen-audio-3.0-realtime-plus

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

Ailoot · Echtzeitstimme 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 Beiträge. Audio lässt sich abschnittsweise senden und empfangen, sodass sich die Interaktion im Verlauf des Gesprächs entwickelt.

Wann das Gegenüber einen Gedanken abgeschlossen hat

Es gibt mehrere Verfahren, um die Grenzen eines Gesprächsbeitrags zu erkennen: anhand von Sprachaktivität, inhaltlicher Vollständigkeit und ausdrücklicher Steuerung. Beim Hersteller wird der Modus vor der ersten Audioübertragung gewählt; eine Änderung nach Gesprächsbeginn erfordert eine neue Verbindung. Ob diese Steuerung unterstützt wird, hängt von der gewählten Methode ab. Der inhaltliche Modus berücksichtigt Pausen und Füllwörter: Ein kurzes Zögern bedeutet nicht zwangsläufig, dass der Nutzer seinen Gedanken abgeschlossen hat. Neue Spracheingaben des Nutzers können die gerade entstehende Antwort unterbrechen, damit das Gespräch mit dem nächsten Beitrag weitergeht. Im inhaltlichen Modus lässt sich die Erkennung an einer Sprachprobe des ausgewählten Gegenübers ausrichten, um andere Stimmen und Hintergrundgeräusche weniger zu berücksichtigen.

Anweisungen legen die Rolle des Assistenten und den Gesprächsstil fest. Die stimmliche Gestaltung kann Tonfall, Tempo und Emotion berücksichtigen; für Version 3.0 sind fünf Systemstimmen und Stimmen anhand einer Sprachprobe vorgesehen. Das Modell unterstützt 11 Sprachen, darunter Russisch, sowie die vom Hersteller angegebenen 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 erfordern Unterstützung durch den gewählten Zugriffsweg.

Werkzeuge und Gesprächsverlauf

Funktionsaufrufe werden unterstützt. Das Modell formuliert die benötigte Aktion, die angebundene Anwendung führt sie aus und gibt das Ergebnis in das Gespräch zurück. Dadurch lässt sich ein Gespräch auf tatsächliche Daten stützen und nach einer ausgeführten Operation fortsetzen. Der Sprachassistent kann Werkzeugergebnisse verwenden und dabei den Gesprächskontext beibehalten. Zu den Herstellerfunktionen gehört auch eine integrierte Websuche, sofern die gewählte Methode sie bereitstellt. Websuche und Funktionsaufrufe können nicht gleichzeitig in einer Sitzung aktiviert werden.

Standardmäßig umfasst der Verlauf 20 Gesprächsschritte; vorgesehen ist ein Bereich von einem bis zu 50. Für das angesammelte Audio gilt ein Limit von 300 Sekunden; bei Überschreitung der Grenzen werden ältere Teile des Verlaufs entfernt. Das ist von der Dauer eines einzelnen Beitrags zu unterscheiden: Der Verlauf bestimmt, welches frühere Material bei der Fortsetzung des Dialogs verfügbar bleibt.

Textkontext und Audio

Der formale Kontext beträgt 40 960 Tokens. Die maximale Eingabelänge liegt bei 16 384 Tokens, die Ausgabelänge bei 8192; dieselben Eingabe- und Ausgabegrenzen sind für den Reasoning-Modus angegeben, mit einem separaten Limit von 1024 Tokens für die Gedankenkette.

Für Audio-Streaming ist einkanaliges PCM mit 16-Bit-Darstellung vorgesehen: 16 kHz für die Eingabe und 24 kHz für die Ausgabe. Text- und Audiodaten gehören zu einem gemeinsamen Gespräch. Visuelle Eingaben und die Ausgabe von Bildern sind für dieses konkrete Modell nicht angegeben; seine Spezialisierung sind Sprache, Text und stimmliche Interaktion.

Ailoot · Echtzeitstimme 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

Start

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

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

In Ailoot verfügbar · Eingaben und Methoden

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

Eingabetypen: text, audio
Ausgabetypen: 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 Byteanzahl	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 EchtzeitstimmeGET /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 abschließenden Verbrauchsdatensatzes. So funktionieren Reservierung und Abrechnung →

Beispielanfragen

Ailoot · Echtzeitstimme

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 · Echtzeitstimme

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 sämtliche zurückgegebenen Audio-Deltas 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`	BedingungKein WebSocket-Upgrade	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