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

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

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

Ailoot Real vaqt rejimidagi ovozGET /v1/realtime?model=qwen-audio-3.0-realtime-plus

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 →

So‘rov namunalari

Ailoot · Real vaqt rejimidagi ovoz

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

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

Usul yo‘llari taxalluslari

Yuqorida ko‘rsatilgan usul yo‘llaridan foydalaning.

Chaqirish uchun tegishli ID lar

qwen-audio-3.0-realtime-plus

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

qwen-audio-3.0-realtime-plus