qwen-audio-3.0-realtime-plus

Modell für Sprachdialoge in Echtzeit, das Sprache und Text annimmt 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 an, antwortet mit Audio und Text und unterstützt ein wechselseitiges Gespräch mit natürlichem Austausch von Äußerungen. Audio kann abschnittsweise gesendet und empfangen werden, sodass sich die Interaktion während des Gesprächs entwickelt.

Wann das Gegenüber seinen Gedanken beendet hat

Es gibt mehrere Möglichkeiten, die Grenzen einer Äußerung festzustellen: anhand der Sprachaktivität, anhand des inhaltlichen Abschlusses und durch ausdrückliche Steuerung. Beim Hersteller wird der Modus vor der Übertragung des ersten Audios gewählt; für einen Wechsel nach Gesprächsbeginn ist eine neue Verbindung erforderlich. 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 zwingend, dass die Person ihren Gedanken beendet hat. Neue Spracheingaben können die gerade erzeugte Antwort unterbrechen, damit das Gespräch unter Berücksichtigung der nächsten Äußerung weitergeht. Im inhaltlichen Modus kann die Erkennung an einem Sprachbeispiel der gewählten Person ausgerichtet werden, damit fremde Stimmen und Hintergrundgeräusche weniger stören.

Anweisungen bestimmen die Rolle des Assistenten und den Gesprächsstil. Die Sprachausgabe kann Tonfall, Tempo und Emotion berücksichtigen; für Version 3.0 sind fünf Systemstimmen und Stimmen anhand eines Sprachbeispiels vorgesehen. Das Modell unterstützt 11 Sprachen, darunter Russisch, sowie die vom Hersteller genannten chinesischen Dialektvarianten. Beim Hersteller wird die Stimme beim ersten Aktualisieren der Sitzungseinstellungen festgelegt; eine später im selben Gespräch übermittelte neue Stimme wird ignoriert. Diese Einstellungen müssen vom gewählten Zugriffsverfahren unterstützt werden.

Werkzeuge und Gesprächsverlauf

Funktionsaufrufe werden unterstützt. Das Modell formuliert die erforderliche Aktion, die angeschlossene Anwendung führt sie aus und gibt das Ergebnis in den Dialog zurück. So kann das Gespräch auf tatsächlichen Daten aufbauen und nach einer ausgeführten Operation fortgesetzt werden. Ein Sprachassistent kann sich auf Werkzeugergebnisse stützen und dabei den Gesprächskontext beibehalten. Zu den Möglichkeiten des Herstellers 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.

Der Verlauf umfasst standardmäßig 20 Gesprächsschritte; vorgesehen ist ein Bereich von einem bis 50. Für das angesammelte Audio gilt eine Grenze von 300 Sekunden. Ältere Teile des Verlaufs werden entfernt, sobald diese Grenzen überschritten sind. Das unterscheidet sich von der Dauer einer einzelnen Äußerung: 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 maximale Ausgabelänge 8192. Dieselben Eingabe- und Ausgabegrenzen gelten für den Reasoning-Modus, mit einer eigenen Grenze von 1024 Tokens für die Gedankenkette.

Für Audio-Streaming ist einkanaliges PCM mit 16-Bit-Darstellung vorgesehen: 16 kHz am Eingang, 24 kHz am Ausgang. Text- und Audiodaten gehören zu einem Gespräch. Visuelle Eingaben und die Ausgabe von Bildern sind für dieses konkrete Modell nicht angegeben; es ist auf Sprache, Text und sprachliche Interaktion spezialisiert.

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 annimmt 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 Audiodaten 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 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 abschließenden 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 alle zurückgegebenen Audiodeltas und Text-/Ereignisergebnisse für jede tatsächliche Antwort-ID zusammen.

Wenn die ursprüngliche Antwort geprüft werden muss

Bewahren Sie tatsächliche Sitzungs-/Antwort-/Ereignis-IDs und 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