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

# qwen-audio-3.0-realtime-plus

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

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

Nutq va matnni qabul qilib, ovoz yoki matn bilan javob beruvchi jonli ovozli muloqot modeli. Tabiiy suhbat sur’ati va vositalar bilan ishlash uchun mo‘ljallangan.

- [**Ailoot · Real vaqt rejimidagi ovoz** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` `qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/uz/qwen-audio-3-0-realtime-plus/#method-0)

Model haqida

Bu tavsif model imkoniyatlarini yoritadi. Ailoot da tanlangan usul uchun mavjud kirish, chiqish va parametrlar quyida keltirilgan.

Qwen-Audio-3.0-Realtime-Plus — Alibaba’ning jonli ovozli muloqot modeli. U nutq va matnni qabul qiladi, audio va matn bilan javob beradi hamda tabiiy navbat almashishga ega ikki tomonlama suhbatni qo‘llab-quvvatlaydi. Ovozni qismlarga bo‘lib yuborish va olish mumkin, shu sababli o‘zaro muloqot suhbat davomida rivojlanadi.

#### Suhbatdosh fikrini qachon tugatganini aniqlash

Replika chegarasini aniqlashning bir necha usuli mavjud: ovoz faolligi, mazmunning tugallanganligi va aniq boshqaruv orqali. Ishlab chiqaruvchida rejim birinchi audio yuborilishidan oldin tanlanadi; suhbat boshlanganidan keyin uni o‘zgartirish uchun yangi ulanish kerak. Bunday boshqaruvning qo‘llab-quvvatlanishi tanlangan metodga bog‘liq. Mazmunga asoslangan rejim pauzalar va nutqdagi to‘ldiruvchi so‘zlarni hisobga oladi: qisqa ikkilanish foydalanuvchi fikrini tugatganini har doim ham anglatmaydi. Foydalanuvchining yangi nutqi shakllanayotgan javobni to‘xtatishi mumkin, shunda suhbat keyingi replika hisobga olingan holda davom etadi. Mazmunga asoslangan rejimda nutqni tanishni tanlangan suhbatdoshning ovoz namunasiga yo‘naltirish mumkin; bu boshqa ovozlar va fon shovqiniga kamroq chalg‘ishga yordam beradi.

Ko‘rsatmalar yordamchining roli va muloqot uslubini belgilaydi. Ovozli ifoda ohang, sur’at va hissiyotni hisobga olishi mumkin; 3.0 versiyasi uchun beshta tizim ovozi va nutq namunasidan yaratilgan ovozlar ko‘zda tutilgan. Model 11 ta tilni, jumladan, rus tilini, shuningdek, ishlab chiqaruvchi ko‘rsatgan xitoy lahja variantlarini qo‘llab-quvvatlaydi. Ishlab chiqaruvchida ovoz sessiya sozlamalari birinchi marta yangilanganda belgilanadi; keyin shu suhbatda yuborilgan yangi ovoz e’tiborga olinmaydi. Bu sozlamalar tanlangan murojaat usuli tomonidan qo‘llab-quvvatlanishi kerak.

#### Vositalar va suhbat tarixi

Funksiya chaqirish qo‘llab-quvvatlanadi. Model kerakli amalni shakllantiradi, ulangan ilova uni bajaradi va natijani suhbatga qaytaradi. Bu suhbatni haqiqiy ma’lumotlarga tayangan holda qurish va bajarilgan amaldan keyin davom ettirish imkonini beradi. Ovozli yordamchi suhbat kontekstini saqlagan holda vositalar natijalariga tayanishi mumkin. Ishlab chiqaruvchi imkoniyatlariga ichki veb-qidiruv ham kiradi, agar tanlangan metod uni taqdim etsa. Veb-qidiruv va funksiya chaqirishni bitta sessiyada bir vaqtda yoqib bo‘lmaydi.

Standart holatda tarix 20 ta suhbat navbatini saqlaydi, birdan 50 tagacha oraliq ko‘zda tutilgan. To‘plangan audio uchun 300 soniyalik chegara belgilangan; cheklovlar oshirilganda tarixning eski qismlari o‘chiriladi. Bu alohida replika davomiyligidan farq qiladi: tarix suhbat davom ettirilganda oldingi materialning qaysi qismi mavjud bo‘lib qolishini belgilaydi.

#### Matn konteksti va ovoz

Rasmiy kontekst hajmi 40 960 tokenni tashkil etadi. Kirishning eng katta uzunligi — 16 384 token, chiqishniki — 8192; mulohaza yuritish rejimi uchun ham shu kirish va chiqish chegaralari ko‘rsatilgan, mulohaza zanjiri uchun esa alohida 1024 tokenlik chegara mavjud.

Oqimli ovoz uchun 16 bitli, bir kanalli PCM ko‘zda tutilgan: kirishda — 16 kHz, chiqishda — 24 kHz. Matn va audio ma’lumotlari bir suhbatga tegishli. Aynan shu model uchun vizual kirish va tasvir chiqarish e’lon qilinmagan; uning ixtisosligi — nutq, matn va ovozli muloqot.

**Ailoot · Real vaqt rejimidagi ovoz** `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/uz/#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`

### Boshlash

Nutq va matnni qabul qilib, ovoz yoki matn bilan javob beruvchi jonli ovozli muloqot modeli. Tabiiy suhbat sur’ati va vositalar bilan ishlash uchun mo‘ljallangan.

Qabul qilinadigan kirish ma’lumotlari

Matn · Audio

Natijalar

Matn · Audio

### Ailoot da mavjud · kirish ma’lumotlari va usullar

**Ailoot · Real vaqt rejimidagi ovoz** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus`

Kirish

`text`, `audio`

Chiqish

`text`, `audio`

Chiqish formati

sessiya voqealari

| Maydon | Tur | Talab | Qiymatlar va cheklovlar | Standart |
| --- | --- | --- | --- | --- |
| Maydon`query.model` | Tur`string` | TalabMajburiy | Qiymatlar va cheklovlar qwen-audio-3.0-realtime-plus | Standart— |
| Maydon`session.input_audio_format` | Tur`string` | TalabIxtiyoriy | Qiymatlar va cheklovlar pcm16, pcm | Standart— |
| Maydon`session.output_audio_format` | Tur`string` | TalabIxtiyoriy | Qiymatlar va cheklovlar pcm16, pcm | Standart— |
| Maydon`session.instructions` | Tur`string` | TalabIxtiyoriy | Qiymatlar va cheklovlar Cheklov qo‘llanadigan obyekt: tanlangan sessiya siyosati | Standart— |
| Maydon`session.max_history_turns` | Tur`integer` | TalabIxtiyoriy | Qiymatlar va cheklovlar Eng kam: 1 Cheklov qo‘llanadigan obyekt: tanlangan sessiya siyosati | Standart— |
| Maydon`input_audio_buffer.append.audio` | Tur`base64_string` | TalabMajburiy | Qiymatlar va cheklovlar Kirish kontenti: PCM16 mono; kirish 16 kHz, chiqish 24 kHz; baytlar soni noldan katta va juft bo‘lishi kerak | Standart— |

Kirish materiallari birikmalari

**realtime\_text\_audio**

Usul parametrlari va hayot sikli

| Parametr | Parametr talablari |
| --- | --- |
| Parametr`material_types` | Parametr talablaritext, audio |
| Parametr`required` | Parametr talablarinull |
| Parametr`optional_controls` | Parametr talablarinull |
| Parametr`content_type` | Parametr talablariWebSocket |

Hayot sikli: `exact retained published method`

Metod tuzilishlari va IDlari aniq; yetkazib beruvchining imkoniyati so‘rovni qabul qilishga ruxsatdan alohida.

### Tariflar

#### Ailoot usullari tariflari

Kirish

0,0008 US$ */ 1K*

Chiqish

0,0064 US$ */ 1K*

Kirish

0,0048 US$ *audio daqiqasi uchun*

Chiqish

0,018 US$ *chiqish audiosining daqiqasi uchun*

Ailoot so‘rovdan oldin taxminiy summani band qiladi. Natijadan keyin o‘lchangan sarf asosidagi yakuniy to‘lovni yechadi. Oqimli javob bo‘yicha yakuniy hisob-kitob yakuniy sarf yozuviga asoslanadi. [Summani band qilish va to‘lovni hisoblash tartibi →](https://ailoot.ai/docs/uz/billing/reserve/)

### So‘rov namunalari

#### Ailoot · Real vaqt rejimidagi ovoz

Python WebSocket · matnPython 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)
```

### Natijalarni olish va saqlash

#### Ailoot · Real vaqt rejimidagi ovoz

sessiya voqealari

##### Barcha tayyor natijalarni saqlash

Qaytarilgan har bir to‘liq javob, fayl va kontent qismini saqlang.

Har bir haqiqiy javob ID si uchun qaytarilgan barcha audio deltalarni va matn/voqea natijalarini yig‘ing.

##### Asl javobni tekshirish kerak bo‘lsa

Haqiqiy sessiya/javob/voqea ID larini va tasdiqlovchi qaydlarni saqlang.

Xatolar va keyingi qadamlar

| Javob | Shart | Keyingi qadam |
| --- | --- | --- |
| Javob426 · `invalid_request_error` | ShartWebSocket ga protokolni almashtirish yo‘q | Keyingi qadamUpgrade: websocket bilan WebSocket mijozidan foydalaning. |

### Taxalluslar

#### Model taxalluslari

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

#### Usul yo‘llari taxalluslari

Yuqorida ko‘rsatilgan usul yo‘llaridan foydalaning.

#### Chaqirish uchun tegishli ID lar

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

Qanday kirish ma’lumotlari va natijalar mavjud?

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

Qanday cheklovlar amal qiladi?

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

Ailoot’ni Claude Code, OpenCode, Hermes yoki ilovangizga ulang.

## Kompaniya va uning loyihalar portfeli

Kompaniya va uning loyihalar portfeli: millionlab mijozlar; oylik sotuvlar hajmi milliardlarda.

## Tokenlarni chegirma bilan xarid qiling.

Muntazam ish uchun obuna chegirmasi. Token xaridiga promokodlar — 50% gacha.

Obuna

Muntazam so‘rovlaringiz uchun chegirmali tarif tanlang.

50% gacha promokod

Xaridda kod kiriting. Narx amaldagi aksiya bilan qayta hisoblanadi.

Tarixdagi xarajatlar

Har so‘rov uchun model, token va summa saqlanadi.

[Obuna tanlash](https://ailoot.ai/docs/uz/billing/subscriptions/) · [Model narxlarini ko‘rish](https://ailoot.ai/models/uz/)

## API’ni sotadigan mahsulotingizga ulang.

SaaS, ilova va botlar Ailoot ofertasi hamda litsenziya shartnomasiga muvofiq. Qayta sotishga reseller litsenziyasi so‘rang.

Tijorat ilovasi

Xizmatingizning pullik funksiyalariga matn, rasm, video va ovoz yaratishni qo‘shing.

Reseller litsenziyasi

Loyiha tavsifi va kirish sxemasini yuboring. Foydalanish va qayta sotishga yozma shartlarni so‘rang.

Saytdagi hujjatlar

Oferta, litsenziya shartnomasi va ma’lumotlar siyosati ulashdan oldin ochiq.

[Reseller litsenziyasini so‘rash](mailto:support@ailoot.ai) · [Oferta va litsenziya shartnomasi](https://ailoot.ai/legal/offer?lang=uz)

## Ailoot · Kompaniya va uning loyihalar portfeli





Ailoot to‘plangan faoliyat tajribasi, keng mijozlar bazasi, barqaror xizmat va doimiy KPI nazoratiga tayanadi.





Kompaniya va uning loyihalar portfeli: millionlab mijozlar; oylik sotuvlar hajmi milliardlarda.





Ailoot bu faoliyat tajribasini mijozlar mahsulotlari, agentlar, ilovalar va avtomatlashtirishlarda AI imkoniyatlariga API orqali kirishni ta’minlashda qo‘llaydi.