Source: https://ailoot.ai/models/de/qwen-audio-3-0-realtime-plus/ Canonical: https://ailoot.ai/models/de/qwen-audio-3-0-realtime-plus/ Language: de # qwen-audio-3.0-realtime-plus [Markdown](https://ailoot.ai/models/de/qwen-audio-3-0-realtime-plus/index.md) · [JSON](https://ailoot.ai/models/de/qwen-audio-3-0-realtime-plus/facts.json) ## [qwen-audio-3.0-realtime-plus](https://ailoot.ai/models/de/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`](https://ailoot.ai/models/de/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 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`](https://ailoot.ai/models/de/#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` ### 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 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 →](https://ailoot.ai/docs/de/billing/reserve/) ### Beispielanfragen #### Ailoot · Echtzeitstimme 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 · 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`](https://ailoot.ai/models/de/#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/#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/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de/) ## 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) ## 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.