Source: https://ailoot.ai/models/de-ch/qwen-audio-3-0-realtime-plus/ Canonical: https://ailoot.ai/models/de-ch/qwen-audio-3-0-realtime-plus/ Language: de-ch # qwen-audio-3.0-realtime-plus [Markdown](https://ailoot.ai/models/de-ch/qwen-audio-3-0-realtime-plus/index.md) · [JSON](https://ailoot.ai/models/de-ch/qwen-audio-3-0-realtime-plus/facts.json) ## [qwen-audio-3.0-realtime-plus](https://ailoot.ai/models/de-ch/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`](https://ailoot.ai/models/de-ch/qwen-audio-3-0-realtime-plus/#method-0) Ü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`](https://ailoot.ai/models/de-ch/#m=qwen-audio-3.0-realtime-plus&route=Core&caller=qwen-audio-3.0-realtime-plus&fmt=realtime) 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 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 →](https://ailoot.ai/docs/de-ch/billing/reserve/) ### Beispielanfragen #### Ailoot · Sprache in Echtzeit Python WebSocket · TextPython WebSocket · Audio ```python # 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) ``` ```python # 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`](https://ailoot.ai/models/de-ch/#m=qwen-audio-3.0-realtime-plus&route=Core&caller=qwen-audio-3.0-realtime-plus&fmt=realtime) #### Aliasnamen für Methodenpfade Verwenden Sie die oben angezeigten Methodenpfade. #### Zugehörige Aufrufer-IDs [`qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/de-ch/#m=qwen-audio-3.0-realtime-plus&route=Core&caller=qwen-audio-3.0-realtime-plus&fmt=realtime) 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` Verbinden Sie Ailoot mit Claude Code, OpenCode, Hermes oder Ihrer eigenen Anwendung. ## Das Unternehmen und sein Projektportfolio Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe. ## Tokens mit Rabatt kaufen. Aborabatt für regelmäßige Arbeit. Aktionscodes bieten bis 50% beim Tokenkauf. Abo Wählen Sie einen Tarif mit Rabatt für Ihre regelmäßigen Anfragen. Aktionscode bis 50% Geben Sie den Code beim Kauf ein. Der Preis wird nach den gültigen Aktionsbedingungen berechnet. Ausgaben in der Historie Modell, Tokens und Betrag werden für jede Anfrage gespeichert. [Abo wählen](https://ailoot.ai/docs/de-ch/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de-ch/) ## Verbinden Sie die API mit dem Produkt, das Sie verkaufen. SaaS, Anwendungen und Bots nach dem offiziellen Angebot und Lizenzvertrag von Ailoot. Fordern Sie für den Weiterverkauf eine Reseller-Lizenz an. Kommerzielle Anwendung Integrieren Sie Text-, Bild-, Video- und Audioerzeugung in kostenpflichtige Funktionen Ihres Dienstes. Reseller-Lizenz Senden Sie Projektbeschreibung und Zugangsmodell. Fordern Sie schriftliche Nutzungs- und Weiterverkaufsbedingungen an. Dokumente auf der Website Offizielles Angebot, Lizenzvertrag und Datenschutzerklärung sind vor der Verbindung zugänglich. [Reseller-Lizenz anfordern](mailto:support@ailoot.ai) · [Offizielles Angebot und Lizenzvertrag](https://ailoot.ai/legal/offer?lang=de-ch) ## Ailoot · Das Unternehmen und sein Projektportfolio Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle. Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe. Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.