Source: https://ailoot.ai/models/sk/qwen-audio-3-0-realtime-plus/
Canonical: https://ailoot.ai/models/sk/qwen-audio-3-0-realtime-plus/
Language: sk

# qwen-audio-3.0-realtime-plus

[Markdown](https://ailoot.ai/models/sk/qwen-audio-3-0-realtime-plus/index.md) · [JSON](https://ailoot.ai/models/sk/qwen-audio-3-0-realtime-plus/facts.json)

## [qwen-audio-3.0-realtime-plus](https://ailoot.ai/models/sk/qwen-audio-3-0-realtime-plus/)

Model na živý hlasový dialóg, ktorý prijíma reč aj text a odpovedá hlasom alebo textom. Je navrhnutý pre prirodzené tempo komunikácie a spoluprácu s nástrojmi.

- [**Ailoot · Hlas v reálnom čase** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` `qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/sk/qwen-audio-3-0-realtime-plus/#method-0)

O modeli

Tento opis pokrýva možnosti modelu. Dostupné vstupy, výstupy a voľby v Ailoot sú uvedené nižšie pre vybranú metódu.

Qwen-Audio-3.0-Realtime-Plus je model spoločnosti Alibaba na živý hlasový dialóg. Prijíma reč a text, odpovedá zvukom a textom a podporuje obojstrannú konverzáciu s prirodzeným striedaním replík. Zvuk možno odovzdávať a prijímať po častiach, takže interakcia sa rozvíja počas rozhovoru.

#### Keď partner dokončí myšlienku

K dispozícii je viacero spôsobov určovania hraníc repliky: podľa zvukovej aktivity, podľa významového ukončenia a pomocou výslovného riadenia. U výrobcu sa režim vyberá pred odovzdaním prvého zvuku; jeho zmena po začatí rozhovoru vyžaduje nové spojenie. Podpora tohto riadenia závisí od zvolenej metódy. Významový režim zohľadňuje pauzy aj výplňové slová: krátke zaváhanie nemusí znamenať, že používateľ dokončil myšlienku. Nová reč používateľa môže prerušiť vznikajúcu odpoveď, aby rozhovor pokračoval so zohľadnením nasledujúcej repliky. Vo významovom režime možno rozpoznávanie orientovať na hlasovú vzorku vybraného partnera, aby ho menej rušili cudzie hlasy a hluk v pozadí.

Inštrukcie určujú rolu asistenta a štýl komunikácie. Hlasový prejav môže zohľadňovať tón, tempo a emócie; verzia 3.0 ponúka päť systémových hlasov a hlasy podľa hlasovej vzorky. Model podporuje 11 jazykov vrátane ruštiny a výrobcom uvedené čínske dialektové varianty. U výrobcu sa hlas zadáva pri prvej aktualizácii nastavení relácie; neskoršie odovzdanie nového hlasu v tej istej konverzácii sa ignoruje. Tieto nastavenia vyžadujú podporu zvoleného spôsobu prístupu.

#### Nástroje a história rozhovoru

Podporované je volanie funkcií. Model navrhne potrebnú akciu, pripojená aplikácia ju vykoná a vráti výsledok do dialógu. Konverzáciu tak možno postaviť na faktických údajoch a pokračovať v nej po vykonanej operácii. Hlasový asistent sa môže opierať o výsledky nástrojov a zachovávať kontext rozhovoru. Možnosti výrobcu zahŕňajú aj vstavané vyhľadávanie na webe, ak ho poskytuje zvolená metóda. Vyhľadávanie na webe a volania funkcií nemožno súčasne zapnúť v jednej relácii.

História štandardne obsahuje 20 kôl rozhovoru; povolený je rozsah od jedného do 50. Pre nahromadený zvuk je stanovený limit 300 sekúnd; pri prekročení obmedzení sa staré časti histórie odstránia. To sa líši od dĺžky samostatnej repliky: história určuje, ktoré predchádzajúce materiály zostávajú dostupné pri pokračovaní dialógu.

#### Textový kontext a zvuk

Formálny kontext je 40 960 tokenov. Maximálna dĺžka vstupu je 16 384 tokenov a výstupu 8192; rovnaké limity vstupu a výstupu sú uvedené pre režim uvažovania, so samostatným limitom reťazca uvažovania 1024 tokenov.

Pre streamovaný zvuk je k dispozícii jednokanálové PCM so 16-bitovým zápisom: na vstupe 16 kHz a na výstupe 24 kHz. Textové a zvukové údaje patria do jednej konverzácie. Vizuálny vstup a výstup obrázkov pre tento konkrétny model nie sú deklarované; jeho špecializáciou je reč, text a hlasová interakcia.

**Ailoot · Hlas v reálnom čase** `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/sk/#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`

### Úvod

Model na živý hlasový dialóg, ktorý prijíma reč aj text a odpovedá hlasom alebo textom. Je navrhnutý pre prirodzené tempo komunikácie a spoluprácu s nástrojmi.

Povolené vstupy

Text · Audio

Výsledky

Text · Audio

### Dostupné v Ailoot · vstupy a metódy

**Ailoot · Hlas v reálnom čase** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus`

Vstup

`text`, `audio`

Výstup

`text`, `audio`

Výstupný formát

udalosti relácie

| Pole | Typ | Požiadavka | Hodnoty a limity | Predvolené |
| --- | --- | --- | --- | --- |
| Pole`query.model` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity qwen-audio-3.0-realtime-plus | Predvolené— |
| Pole`session.input_audio_format` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity pcm16, pcm | Predvolené— |
| Pole`session.output_audio_format` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity pcm16, pcm | Predvolené— |
| Pole`session.instructions` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Limit sa vzťahuje na: vybraná politika relácie | Predvolené— |
| Pole`session.max_history_turns` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 1 Limit sa vzťahuje na: vybraná politika relácie | Predvolené— |
| Pole`input_audio_buffer.append.audio` | Typ`base64_string` | PožiadavkaPovinné | Hodnoty a limity Vstupný obsah: PCM16 mono; vstup 16 kHz, výstup 24 kHz; neprázdna párna dĺžka v bajtoch | Predvolené— |

Kombinácie vstupných podkladov

**realtime\_text\_audio**

Parametre a životný cyklus metódy

| Parameter | Špecifikácia |
| --- | --- |
| Parameter`material_types` | Špecifikáciatext, audio |
| Parameter`required` | Špecifikácianull |
| Parameter`optional_controls` | Špecifikácianull |
| Parameter`content_type` | ŠpecifikáciaWebSocket |

Životný cyklus: `exact retained published method`

Štruktúry metód a ID sú presné; možnosti dodávateľa sa posudzujú oddelene od prijatia požiadavky.

### Cenník

#### Sadzby metód Ailoot

Vstup

0,0008 USD */ 1K*

Výstup

0,0064 USD */ 1K*

Vstup

0,0048 USD *za minútu audia*

Výstup

0,018 USD *za minútu výstupného audia*

Ailoot pred požiadavkou rezervuje odhadovanú sumu. Po získaní výsledku vyúčtuje konečný poplatok podľa nameraného využitia. Pri streamovaní sa vyúčtovanie riadi konečným záznamom využitia. [Ako funguje rezervácia a vyúčtovanie →](https://ailoot.ai/docs/sk/billing/reserve/)

### Príklady požiadaviek

#### Ailoot · Hlas v reálnom čase

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)
```

### Prijať a uložiť výsledky

#### Ailoot · Hlas v reálnom čase

udalosti relácie

##### Uchovať všetky dokončené výsledky

Uložte každú úplnú vrátenú odpoveď, súbor a časť obsahu.

Zostavte všetky vrátené zvukové prírastky a výsledky textu alebo udalostí pre každé skutočné ID odpovede.

##### Ak treba overiť pôvodnú odpoveď

Zachovajte skutočné ID relácií, odpovedí a udalostí aj záznamy o nich.

Chyby a ďalšie kroky

| Odpoveď | Podmienka | Ďalší krok |
| --- | --- | --- |
| Odpoveď426 · `invalid_request_error` | PodmienkaBez prepnutia protokolu na WebSocket | Ďalší krokPoužite klienta WebSocket s Upgrade: websocket. |

### Aliasy

#### Aliasy modelov

**Ailoot** [`qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/sk/#m=qwen-audio-3.0-realtime-plus&route=Core&caller=qwen-audio-3.0-realtime-plus&fmt=realtime)

#### Aliasy ciest metód

Použite cesty metód uvedené vyššie.

#### Súvisiace ID na volanie

[`qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/sk/#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

Aké vstupy a výsledky sú dostupné?

`GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` · `qwen-audio-3.0-realtime-plus`: `text`, `audio` → `text`, `audio`

Aké limity platia?

`GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` · `qwen-audio-3.0-realtime-plus`: `session.max_history_turns.minimum`: `1`

Pripojte Ailoot k Claude Code, OpenCode, Hermes alebo vlastnej aplikácii.

## Spoločnosť a jej portfólio projektov

Spoločnosť a jej portfólio projektov: milióny zákazníkov; mesačné tržby v miliardách.

## Nakupujte tokeny so zľavou.

Zľava predplatného na pravidelnú prácu. Promo kódy až 50% na nákup tokenov.

Predplatné

Na pravidelné požiadavky vyberte tarifu so zľavou.

Promo kód až 50%

Pri nákupe zadajte kód. Cena sa prepočíta podľa prebiehajúcej akcie.

Výdavky v histórii

Pri každej požiadavke sa uloží model, tokeny a suma.

[Vybrať predplatné](https://ailoot.ai/docs/sk/billing/subscriptions/) · [Zobraziť ceny modelov](https://ailoot.ai/models/sk/)

## Pripojte API k produktu, ktorý predávate.

SaaS, aplikácie a boti podľa ponuky a licenčnej zmluvy Ailoot. Na ďalší predaj požiadajte o licenciu predajcu.

Komerčná aplikácia

Začleňte generovanie textu, obrázkov, videa a zvuku do platených funkcií svojej služby.

Licencia pre predajcu

Pošlite popis projektu a spôsob poskytovania prístupu. Vyžiadajte písomné podmienky použitia a ďalšieho predaja.

Dokumenty na webe

Ponuka, licenčná zmluva a zásady spracovania dát sú dostupné pred pripojením.

[Požiadať o licenciu predajcu](mailto:support@ailoot.ai) · [Ponuka a licenčná zmluva](https://ailoot.ai/legal/offer?lang=sk)

## Ailoot · Spoločnosť a jej portfólio projektov





Ailoot stavia na dlhodobých prevádzkových skúsenostiach, širokej klientskej základni, stabilných službách a priebežnom sledovaní KPI.





Spoločnosť a jej portfólio projektov: milióny zákazníkov; mesačné tržby v miliardách.





Ailoot využíva tieto prevádzkové skúsenosti na poskytovanie prístupu cez API k funkciám AI v produktoch zákazníkov, agentoch, aplikáciách a automatizáciách.