Skip to main content

Qwen-Omni-Realtime

Utilisez Qwen-Omni-Realtime via WebSocket ou WebRTC pour comprendre le texte, les images, l’audio et la vidéo, et produire des réponses vocales pour les conversations vocales, le service client et des applications similaires.

Régions prises en charge : Singapour, Chine (Pékin). Chaque région nécessite sa propre clé API.

Choix du modèle

Utilisez Qwen3.8-Omni-Flash-Realtime pour les conversations audio/vidéo en temps réel. Il prend en charge les interactions duplex intégral, accepte le texte, les images, l’audio en streaming et la vidéo, et renvoie du texte et de l’audio.
Consultez la console Model Studio pour les noms de modèles, le contexte, la tarification et les versions figées. Pour les limites de concurrence, consultez Limitation du débit.
Les modèles Qwen-Omni-Realtime prennent en charge les connexions WebSocket, WebRTC et AOQ. WebSocket convient à l’intégration côté serveur et à une prise en main rapide. WebRTC convient aux scénarios vocaux à faible latence dans le navigateur. Il transmet l’audio directement sur UDP et inclut l’annulation de l’écho et la réduction du bruit. Pour une intégration côté client donnant la priorité à une latence stable, aux interactions sur réseau dégradé et à la réduction du bruit et de l’écho en communication duplex intégral en temps réel, envisagez d’abord AOQ. Pour comparer les protocoles et choisir, consultez la Référence de l’API. Choisissez une entrée selon votre tâche :

Prérequis de connexion

Obtenez une API Key et un ID d’espace de travail pour la région et l’espace de travail sélectionnés, puis définissez l’API Key comme variable d’environnement. qwen3.8-omni-flash-realtime nécessite le point de terminaison propre à l’espace de travail ci-dessous.
  • WebSocket
  • WebRTC
  • AOQ
ParamètreDescription
Point de terminaisonRégion Singapour : wss://WorkspaceId.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtimeRemplacez WorkspaceId par l’ID réel de votre espace de travail.
Paramètre de requêteUtilisez le paramètre de requête model pour indiquer le modèle. Exemple : ?model=qwen3.8-omni-flash-realtime
En-tête de requêteAuthentifiez-vous avec un jeton Bearer : Authorization: Bearer DASHSCOPE_API_KEY
DASHSCOPE_API_KEY est la clé API de Model Studio.

Premiers pas

Cet exemple WebSocket en mode Manual réalise un échange à partir d’un fichier audio local. Pour une entrée microphone continue ou une interaction dans le navigateur, consultez Exemples de conversation en temps réel. Configurez une API Key et installez websocket-client. Dans l’exemple Python ci-dessous, définissez la région (cn-beijing ou ap-southeast-1) et saisissez l’ID de votre espace de travail dans l’URL correspondante. Définissez PCM_FILE sur un court fichier vocal PCM mono, 16 kHz, 16-bit little-endian, sans en-tête de fichier. Cet exemple utilise le mode Manual : attendez la configuration de session, envoyez l’audio, soumettez le tampon et demandez une réponse. Le texte s’affiche dans le terminal ; l’audio est enregistré dans reply.pcm, au format PCM 24 kHz et non WAV. Exécutez les commandes suivantes dans un terminal macOS ou Linux.
python3 -m pip install websocket-client
export PCM_FILE="./input.pcm"
Si vous avez un fichier WAV PCM mono, 16 kHz, 16-bit nommé input.wav, utilisez Python pour extraire ses trames PCM. Cette étape vérifie le format et ne rééchantillonne pas l’audio.
import wave
from pathlib import Path

with wave.open("input.wav", "rb") as source:
    if (source.getnchannels(), source.getframerate(), source.getsampwidth(),
            source.getcomptype()) != (1, 16000, 2, "NONE"):
        raise ValueError("Expected mono 16 kHz, 16-bit PCM WAV audio.")
    Path("input.pcm").write_bytes(source.readframes(source.getnframes()))
Exécutez le client suivant après avoir préparé l’entrée. L’exemple utilise la voix Long An Ling Xin (longanlingxin) :
import base64
import json
import os
from pathlib import Path
import websocket

url = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime?model=qwen3.8-omni-flash-realtime"
audio = Path(os.environ["PCM_FILE"]).read_bytes()
if not audio or len(audio) % 2:
    raise ValueError("Provide non-empty 16-bit mono PCM audio.")

ws = websocket.create_connection(
    url,
    header=["Authorization: Bearer " + os.environ["DASHSCOPE_API_KEY"]],
    timeout=30,
)

def receive():
    event = json.loads(ws.recv())
    if event["type"] == "error":
        raise RuntimeError(event.get("error"))
    return event

try:
    while receive()["type"] != "session.created":
        pass
    ws.send(json.dumps({
        "type": "session.update",
        "session": {
            "modalities": ["text", "audio"],
            "turn_detection": None,
            "audio": {
                "input": {"format": {
                    "type": "pcm", "sample_rate": 16000,
                    "sample_format": "s16le", "channels": 1,
                    "packing": "interleaved", "channel_layout": "mono",
                }},
                "output": {
                    "voice": "longanlingxin",
                    "format": {"type": "pcm", "sample_rate": 24000},
                },
            },
        },
    }))
    while receive()["type"] != "session.updated":
        pass
    for offset in range(0, len(audio), 3200):
        ws.send(json.dumps({
            "type": "input_audio_buffer.append",
            "audio": base64.b64encode(audio[offset:offset + 3200]).decode("ascii"),
        }))
    ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
    while receive()["type"] != "input_audio_buffer.committed":
        pass
    ws.send(json.dumps({"type": "response.create"}))
    with open("reply.pcm", "wb") as output:
        while True:
            event = receive()
            if event["type"] == "response.audio.delta":
                output.write(base64.b64decode(event["delta"]))
            elif event["type"] in ("response.audio_transcript.delta", "response.text.delta"):
                print(event["delta"], end="", flush=True)
            elif event["type"] == "response.done":
                print("\nResponse status:", event["response"]["status"])
                break
finally:
    ws.close()
Après une réponse réussie, convertissez reply.pcm en fichier WAV pour le lire dans un lecteur audio :
import wave
from pathlib import Path

with wave.open("reply.wav", "wb") as target:
    target.setnchannels(1)
    target.setsampwidth(2)
    target.setframerate(24000)
    target.writeframes(Path("reply.pcm").read_bytes())

Exemples de conversation en temps réel

Sélectionnez un langage de programmation et suivez les étapes pour démarrer un chat en temps réel.
  • WebSocket
  • WebRTC
  • AOQ
  • SDK DashScope Python
  • SDK DashScope Java
  • WebSocket (Python)
  • Environnement d'exécution
Vérifiez que Python 3.10 ou une version ultérieure est installé.Installez PyAudio pour votre système d'exploitation.
  • macOS
  • Debian/Ubuntu
  • CentOS
  • Windows
brew install portaudio && pip install pyaudio
Installez les autres dépendances :
pip install websocket-client dashscope
  • Mode d'interaction
    • Mode VAD (Voice Activity Detection, détection automatique du début et de la fin de la parole) Le serveur répond après avoir détecté la fin de l'énoncé de l'utilisateur.
    • Mode manuel (appuyez pour parler, relâchez pour envoyer) Le client contrôle le début et la fin de la parole. Une fois l'énoncé terminé, votre application doit en informer le serveur.
    • Mode VAD
    • Mode manuel
    Créez un fichier Python nommé vad_dash.py et copiez-y le code suivant :
    # Dependencies: dashscope >= 2.0.1, pyaudio
    import os
    import base64
    import time
    
    import pyaudio
    from concurrent.futures import ThreadPoolExecutor
    
    import dashscope
    
    # La configuration suivante concerne la région Singapour (ap-southeast-1). Saisissez l’ID de votre espace de travail dans l’exemple. La valeur de region varie selon la région.
    client = dashscope.Client(
        # If you have not set an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
        # API keys are region-specific. To get an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        workspace="{WorkspaceId}",
        region="ap-southeast-1",
    )
    # Specify the voice
    voice = 'Tina'
    # Specify the model
    model = 'qwen3.8-omni-flash-realtime'
    # Specify the model persona
    instructions = "You are Xiaoyun, a personal assistant. Answer the user's questions in a humorous and witty way."
    
    # 1. Initialize the audio device and output stream
    pya = pyaudio.PyAudio()
    out = pya.open(format=pyaudio.paInt16, channels=1, rate=24000, output=True)
    
    # 2. Receiver thread: iterate server events, play audio and print text
    def receive_events(session):
        for response in session.events():
            if response['type'] == 'response.audio.delta':
                # Play the audio.
                out.write(base64.b64decode(response['delta']))
            elif response['type'] == 'conversation.item.input_audio_transcription.delta':
                # Streaming preview: text is the confirmed prefix, stash is the unconfirmed suffix.
                preview = response.get('text', '') + response.get('stash', '')
                print(f"\r[User] {preview}", end='', flush=True)
            elif response['type'] == 'conversation.item.input_audio_transcription.completed':
                # Transcription completed. Print the final text and move to a new line.
                print(f"\r[User] {response['transcript']}")
            elif response['type'] == 'response.audio_transcript.done':
                # Print the assistant's response text.
                print(f"[LLM] {response['transcript']}")
    
    # 3. Create the session (the connection is established automatically on entering the with context) and configure it
    with client.audio.realtime.connect(model=model) as session:
        session.update_session(
            output_modalities=['audio', 'text'],
            voice=voice,
            instructions=instructions,
        )
        # 4. Initialize the audio input stream.
        mic = pya.open(format=pyaudio.paInt16, channels=1, rate=16000, input=True)
        # 5. Main loop to process audio input.
        print("Conversation started. Speak into the microphone (Ctrl+C to exit)...")
        try:
            with ThreadPoolExecutor(max_workers=1) as pool:
                receiver = pool.submit(receive_events, session)
                while True:
                    audio_data = mic.read(3200, exception_on_overflow=False)
                    session.append_audio(audio_data)
                    time.sleep(0.01)
        except KeyboardInterrupt:
            # Clean up resources.
            session.close()
            mic.close()
            out.close()
            pya.terminate()
            print("\nConversation ended")
    
    Exécutez vad_dash.py pour démarrer une conversation en temps réel via votre microphone. Le système détecte la parole et diffuse le flux audio vers le serveur.

Utilisation

Un appel établit une connexion, configure la session, envoie l’entrée, déclenche une réponse et reçoit les résultats.

1. Établir la connexion

Les exemples de connexion WebSocket et WebRTC suivants utilisent qwen3.8-omni-flash-realtime.
  • WebSocket
  • WebRTC
  • AOQ
  • WebSocket natif
  • SDK DashScope Python
  • SDK DashScope Java
Pour les points de terminaison et l’authentification, consultez Prérequis de connexion.
# pip install websocket-client
import json
import websocket
import os

API_KEY=os.getenv("DASHSCOPE_API_KEY")
# Région Singapour. Saisissez l’ID de votre espace de travail dans l’exemple. Les URL varient selon la région.
API_URL = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime?model=qwen3.8-omni-flash-realtime"

headers = [
    "Authorization: Bearer " + API_KEY
]

def on_open(ws):
    print(f"Connected to server: {API_URL}")
def on_message(ws, message):
    data = json.loads(message)
    print("Received event:", json.dumps(data, indent=2))
def on_error(ws, error):
    print("Error:", error)

ws = websocket.WebSocketApp(
    API_URL,
    header=headers,
    on_open=on_open,
    on_message=on_message,
    on_error=on_error
)

ws.run_forever()

Configurer la session

Définissez instructions dans l’objet session d’un événement session.update pour fournir le contexte et les exigences de réponse. Utilisez l’événement client session.update pour configurer les modalités de sortie, la voix, le format audio et la VAD. La configuration WebSocket en mode Manual suivante pour Qwen3.8-Omni-Flash-Realtime correspond à l’exemple audio minimal. Cet exemple utilise la voix Long An Ling Xin (longanlingxin) :
{
  "type": "session.update",
  "session": {
    "modalities": [
      "text",
      "audio"
    ],
    "turn_detection": null,
    "audio": {
      "input": {
        "format": {
          "type": "pcm",
          "sample_rate": 16000,
          "sample_format": "s16le",
          "channels": 1,
          "packing": "interleaved",
          "channel_layout": "mono"
        }
      },
      "output": {
        "voice": "longanlingxin",
        "format": {
          "type": "pcm",
          "sample_rate": 24000
        }
      }
    }
  }
}
L’exemple suivant utilise Qwen3.5-Omni-Realtime, la voix Ethan et le mode semantic_vad.
{
    // A client-generated event ID.
    "event_id": "event_ToPZqeobitzUJnt3QqtWg",
    // The event type. Must be "session.update".
    "type": "session.update",
    // The session configuration.
    "session": {
        // The output modality. Set this to ["text"] for text-only output, or ["text", "audio"] for both text and audio output.
        "modalities": [
            "text",
            "audio"
        ],
        // The voice for the audio output.
        "voice": "Ethan",
        // The input audio format. Only "pcm" is supported. The input audio must be a PCM audio stream at a 16 kHz sample rate.
        "input_audio_format": "pcm",
        // The output audio format. Only "pcm" is supported. The output audio is a PCM audio stream at a 24 kHz sample rate.
        "output_audio_format": "pcm",
        // A system instruction to define the model's goal or role.
        "instructions": "You are an AI customer service agent for a five-star hotel. Answer customer inquiries about room types, facilities, prices, and booking policies accurately and in a friendly manner. Always respond with a professional and helpful attitude. Do not provide unconfirmed information or information beyond the scope of the hotel's services.",
        // Enables server-side voice activity detection (VAD). If enabled, the server automatically detects the start and end of speech.
        // If null, the client controls when to trigger model responses.
        "turn_detection": {
            // The VAD type. Valid values: "server_vad" and "semantic_vad". We recommend "semantic_vad" for the qwen3.5-omni-realtime series model.
            "type": "semantic_vad",
            // The VAD detection threshold. We recommend increasing this value in noisy environments and decreasing it in quiet environments.
            "threshold": 0.5,
            // The silence duration in milliseconds (ms) that signals the end of an utterance. The model triggers a response if this duration is exceeded.
            "silence_duration_ms": 800
        }
    }
}
Pour les formats de médias et l’entrée multicanal, consultez Fonctionnalités d’entrée et de sortie ; pour la configuration des outils, consultez Outils et recherche web.

Déroulement de l'interaction

  • Mode VAD
  • Mode manuel
Définissez session.turn_detection.type dans l’événement session.update sur "server_vad" ou "semantic_vad" pour activer le mode VAD. Ce mode convient aux appels vocaux. WebSocket et WebRTC prennent tous deux en charge le mode VAD, mais leurs méthodes de transport audio et image ainsi que certains événements serveur diffèrent.Pour le service client ou les conversations métier avec la série Qwen3.8-Omni-Flash-Realtime, définissez session.turn_detection.type sur "semantic_vad_ec". Par rapport à semantic_vad, ce mode détecte plus facilement la parole de l’utilisateur pour interrompre la réponse du modèle, tout en filtrant les sons sans signification comme le bruit de fond.
WebRTC prend uniquement en charge le mode VAD, sans le mode Manual. WebRTC transmet l’audio directement sur RTP ; vous n’avez donc pas besoin d’envoyer les événements input_audio_buffer.append. Les images sont transmises sur les pistes vidéo, et les événements input_image_buffer.append ne sont pas pris en charge. Les instructions de contrôle et les événements serveur passent par DataChannel. Pour plus d’informations, consultez Événements serveur.
Le flux d'interaction se déroule comme suit :
  1. Le client transmet l'audio via les événements input_audio_buffer.append avec WebSocket, ou automatiquement sur la piste RTP avec WebRTC, sans événement manuel.
  2. Le serveur détecte le début de parole et envoie input_audio_buffer.speech_started via DataChannel (WebRTC) ou WebSocket.
  3. Le serveur détecte la fin de parole et envoie input_audio_buffer.speech_stopped.
  4. Le serveur soumet le tampon audio et envoie input_audio_buffer.committed.
  5. Le serveur commence la réponse en envoyant conversation.item.created et d'autres événements. L'audio est renvoyé progressivement via l'événement WebSocket response.audio.delta ou directement sur la piste RTP de WebRTC.
  6. Pendant la réponse, le serveur renvoie la transcription progressive via response.audio_transcript.delta, puis envoie response.done à la fin.
Cycle de vieÉvénements clientÉvénements serveur
Initialisation de la sessionsession.update
Configuration de la session
session.created
Session créée.
session.updated
Configuration de la session mise à jour.
Entrée audio utilisateurinput_audio_buffer.append
WebSocket : ajoute l'audio au tampon.
input_image_buffer.append
WebSocket : ajoute une image au tampon.
WebRTC : l'audio et les images sont transmis automatiquement sur les pistes RTP audio et vidéo ; ces événements ne sont pas nécessaires.
input_audio_buffer.speech_started
Début de parole détecté.
input_audio_buffer.speech_stopped
Fin de parole détectée.
input_audio_buffer.committed
Tampon audio soumis.
Sortie audio serveurAucunresponse.created
Début de la génération.
response.output_item.added
Élément de sortie ajouté.
conversation.item.created
Élément de conversation créé.
response.content_part.added
Partie de contenu ajoutée au message de l'assistant.
response.audio_transcript.delta
Transcription textuelle progressive.
response.audio.delta
WebSocket : audio généré progressivement. WebRTC : l'audio passe directement par RTP et cet événement n'est pas renvoyé.
response.audio_transcript.done
Transcription terminée.
response.audio.done
Génération audio terminée.
response.content_part.done
Fin du streaming de la partie textuelle ou audio.
response.output_item.done
Fin du streaming de l'élément de sortie complet.
response.done
Réponse terminée.
conversation.item.input_audio_transcription.completed
Transcription de l'audio utilisateur terminée ; nécessite input_audio_transcription dans session.update.

Terminer une session

Fermez la connexion à la fin de la conversation. Pour WebSocket, appelez close(). Pour WebRTC, arrêtez les médias et fermez PeerConnection selon Terminer une session et libérer les ressources. Si la même session reste ouverte, son contexte continue de s’accumuler. Lorsque close() est appelé immédiatement après la connexion, avant toute interaction, la fermeture WebSocket peut prendre environ 5–10 secondes. Le serveur doit terminer le traitement des flux audio, la mise en cache du contexte et l’initialisation des ressources d’inférence avant de répondre à la demande de fermeture. Exécutez close() de manière asynchrone pour ne pas bloquer le flux principal.

Limites

qwen3.8-omni-flash-realtime prend en charge jusqu’à 196608 tokens d’entrée au total. La longueur d’entrée est calculée selon les mêmes règles que Qwen3.5-Omni-Realtime.
  • Si le nombre total de tokens de l’historique et du tour actuel dépasse la longueur d’entrée maximale, le serveur tronque automatiquement l’historique et poursuit la conversation. Le texte et les résultats d’outils comptent aussi dans la longueur d’entrée.
  • Si le tour actuel seul dépasse la longueur d’entrée maximale, le serveur renvoie une erreur.
  • Une session WebSocket peut durer jusqu’à 120 minutes. La connexion se ferme automatiquement à cette limite.
  • Le modèle conserve l’historique selon les limites suivantes de tours et de durée. Au-delà, l’historique le plus ancien est supprimé. La durée maximale est la durée cumulée d’audio ou de vidéo (trames d’images) conservée dans le contexte, et non la durée de la session entière.
    La vidéo est fournie sous forme de trames extraites, avec une recommandation de 1 fps. La durée vidéo maximale est la durée cumulée des trames conservées ; par exemple, 240 s signifie que seules les trames des 240 dernières secondes sont gardées.

    Modèle

    Nombre maximal de tours audio

    Nombre maximal de tours vidéo

    Durée audio maximale

    Durée vidéo maximale

    qwen3.8-omni-flash-realtime

    100 tours

    50 tours

    600 secondes

    240 secondes

    qwen3.5-omni-plus-realtime

    100 tours

    50 tours

    600 secondes

    240 secondes

    qwen3.5-omni-flash-realtime

    80 tours

    50 tours

    480 secondes

    120 secondes

Fonctionnalités d’entrée et de sortie

Choisissez l’entrée audio, les images et la vidéo, l’audio multicanal ou les voix. Pour Function Calling, MCP et la recherche web, consultez Outils et recherche web.

Entrée audio

L’audio est l’entrée principale recommandée, avec des images facultatives. Pour WebSocket, ajoutez l’audio encodé en Base64 via input_audio_buffer.append. WebRTC transmet automatiquement l’audio sur la piste RTP ajoutée à la connexion, sans cet événement. Consultez Configuration de la session pour les formats et Exemples de conversation en temps réel pour l’enregistrement et l’envoi.

Entrée image et vidéo

Les images peuvent venir de fichiers locaux ou être capturées depuis un flux vidéo en direct. Choisissez la méthode d’envoi selon votre protocole :
  • WebSocket
  • WebRTC
Envoyez les images encodées en Base64 au tampon du serveur via input_image_buffer.append. Avant d’envoyer une image, envoyez au moins un événement input_audio_buffer.append.
  • Mode VAD : le serveur soumet automatiquement l’audio et les images et déclenche une réponse à la fin de la parole. Envoyez les images du tour avant input_audio_buffer.speech_stopped.
  • Mode Manual : après avoir ajouté l’audio et les images du tour, envoyez input_audio_buffer.commit, attendez input_audio_buffer.committed, puis envoyez response.create pour demander une réponse. Consultez la séquence des événements.
Pour les images locales, ouvrez Exemples de conversation en temps réel, choisissez “WebSocket → Native Python WebSocket → Manual mode”, développez manual_mode.py et décommentez ses sections d’entrée et d’envoi d’images.Pour les appels vidéo, extrayez les trames et envoyez-les via input_image_buffer.append au rythme recommandé d’une trame par seconde. Pour le code SDK, consultez les Exemples de code Omni-Realtime.

Facultatif : agrégation vidéo

Pour Qwen3.8-Omni-Flash-Realtime, session.video.input.representation_compact vaut none par défaut. Définissez-le sur normal pour agréger les représentations vidéo et réduire le calcul lorsque les détails visuels fins sont inutiles. Configurez-le avant le premier segment audio ; il ne peut plus changer après le début de l’entrée audio. La configuration ci-dessous utilise le mode Manual, une sortie textuelle et audio, la voix Tina et la transcription d’entrée désactivée. conversation est une session SDK connectée. Le SDK envoie aussi les réglages de voix et de VAD ; fournissez les modifications dans le même appel.
  • Python
  • Java
Utilisez le SDK Python DashScope 2.0.1 ou ultérieur. Dans Exemples de conversation en temps réel, sélectionnez “WebSocket → DashScope Python SDK → Manual mode” :
  1. Dans manual_dash.py, définissez le modèle sur qwen3.8-omni-flash-realtime.
  2. Remplacez l’appel update_session existant par celui ci-dessous ; input_video_representation_compact est la configuration d’agrégation vidéo. Appliquez-le une seule fois avant le premier segment audio.
  3. Comme cette configuration désactive la transcription d’entrée, omettez ctx['transcription_done'].wait(timeout=10) après la soumission. Conservez les appels existants de soumission et de création de réponse.
Python
session.update_session(
    output_modalities=['audio', 'text'],
    voice="Tina",
    enable_turn_detection=False,
    enable_input_audio_transcription=False,
    input_video_representation_compact="normal",
)
Après la configuration, suivez Entrée image et vidéo pour envoyer les trames. Pour le calcul des tokens vidéo, consultez Facturation.

Audio multicanal

La configuration suivante s’applique aux connexions WebSocket à Qwen3.8-Omni-Flash-Realtime. Configurez session.audio.input.format avant le premier segment audio. Il prend en charge 1, 2 ou 4 canaux ; l’entrée multicanal nécessite PCM, 16000 Hz, s16le et des échantillons interleaved. Utilisez raw_mic_array pour 2 canaux et foa_ambix pour 4. Consultez les événements client pour les contraintes et fragments JSON. Pour le multiplicateur des tokens d’entrée, consultez Facturation.

4. Recevoir les réponses du modèle

Le format de réponse varie selon la modalité de sortie configurée.
  • WebSocket
  • WebRTC

Liste des voix

La configuration suivante s’applique à Qwen3.8-Omni-Flash-Realtime. La voix par défaut est Tina. Utilisez session.audio.output.voice pour les nouvelles intégrations. Si ce champ et le champ de compatibilité session.voice sont tous deux définis, la sortie audio utilise la voix indiquée par session.audio.output.voice. Consultez les voix Qwen3.8 pour les voix et aperçus disponibles, le clonage de voix pour les voix personnalisées et la liste complète des voix pour les autres modèles.

Outils et recherche web

  • La recherche web et les appels d’outils s’excluent mutuellement.
Appel de fonctions permettant au modèle d'invoquer automatiquement des outils externes. Pour en savoir plus, reportez-vous à la rubrique Série Qwen-Omni-Realtime. Renvoyez les résultats Function Calling avec conversation.item.create et item.type=function_call_output.

MCP

La configuration suivante s’applique à Qwen3.8-Omni-Flash-Realtime. Configurez un service public HTTPS MCP Streamable HTTP dans session.tools. Mettez à jour la configuration MCP uniquement en l’absence de Response active. L’approbation est obligatoire par défaut. Attendez la fin de la découverte avant de créer une Response nécessitant l’outil. Consultez le Déroulement des interactions MCP pour les résultats, les rejets, les échecs et la continuation.

Recherche web

La recherche web permet au modèle d’utiliser des données en temps réel pour répondre aux questions d’actualité, comme les cours boursiers ou la météo. Le modèle décide automatiquement si une recherche est nécessaire.
Qwen3.8-Omni-Flash-Realtime et la série Qwen3.5-Omni-Realtime prennent en charge la recherche web. Désactivée par défaut, elle s’active avec session.update.
Pour la facturation, consultez la politique agent dans les règles de facturation.

Activer la recherche web

Ajoutez les paramètres suivants à l'événement session.update :
  • enable_search : définissez sur true pour activer la recherche web.
  • search_options.enable_source : définissez sur true pour inclure les sources des résultats dans la réponse.
Pour les autres paramètres, consultez session.update.

Réponses et exécution de la recherche

Recevez les réponses via les événements textuels et audio habituels. Après response.done, les exemples ci-dessous lisent count et strategy dans la consommation de recherche et affichent le nombre de recherches et la stratégie. Consultez Consommation de recherche pour ces champs.

Exemple de code

Activez la recherche web dans une conversation en temps réel :
  • SDK DashScope Python
  • SDK DashScope Java
  • WebSocket (Python)
Transmettez les paramètres enable_search et search_options lors de l'appel à update_session :
import os
import base64
import time

import pyaudio
from concurrent.futures import ThreadPoolExecutor

import dashscope

# La configuration suivante concerne la région Singapour (ap-southeast-1). Saisissez l’ID de votre espace de travail dans l’exemple. La valeur de region varie selon la région.
client = dashscope.Client(
    # If you have not set an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
    # API keys are region-specific. To get an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)
model = 'qwen3.8-omni-flash-realtime'
voice = 'Tina'

pya = pyaudio.PyAudio()
out = pya.open(format=pyaudio.paInt16, channels=1, rate=24000, output=True)

# Receiver thread: iterate server events
def receive_events(session):
    for response in session.events():
        if response['type'] == 'response.audio.delta':
            out.write(base64.b64decode(response['delta']))
        elif response['type'] == 'conversation.item.input_audio_transcription.delta':
            preview = response.get('text', '') + response.get('stash', '')
            print(f"\r[User] {preview}", end='', flush=True)
        elif response['type'] == 'conversation.item.input_audio_transcription.completed':
            print(f"\r[User] {response['transcript']}")
        elif response['type'] == 'response.audio_transcript.done':
            print(f"[LLM] {response['transcript']}")
        elif response['type'] == 'response.done':
            usage = response.get('response', {}).get('usage', {})
            plugins = usage.get('plugins', {})
            if plugins.get('search'):
                print(f"[Search] count={plugins['search']['count']}, strategy={plugins['search']['strategy']}")

with client.audio.realtime.connect(model=model) as session:
    session.update_session(
        output_modalities=['audio', 'text'],
        voice=voice,
        instructions="You are Xiaoyun, a personal assistant.",
        enable_search=True,
        search_options={'enable_source': True}
    )
    mic = pya.open(format=pyaudio.paInt16, channels=1, rate=16000, input=True)
    print("Web search is enabled. Speak into the microphone (Ctrl+C to exit)...")
    try:
        with ThreadPoolExecutor(max_workers=1) as pool:
            receiver = pool.submit(receive_events, session)
            while True:
                audio_data = mic.read(3200, exception_on_overflow=False)
                session.append_audio(audio_data)
                time.sleep(0.01)
    except KeyboardInterrupt:
        session.close()
        mic.close()
        out.close()
        pya.terminate()
        print("\nConversation ended.")

Format de réponse

Lorsque la recherche web est activée, l'objet usage dans response.done contient un champ plugins avec les informations de comptage de la recherche :
{
    "usage": {
        "total_tokens": 2937,
        "input_tokens": 2554,
        "output_tokens": 383,
        "input_tokens_details": {
            "text_tokens": 2512,
            "audio_tokens": 42
        },
        "output_tokens_details": {
            "text_tokens": 90,
            "audio_tokens": 293
        },
        "plugins": {
            "search": {
                "count": 1,
                "strategy": "agent"
            }
        }
    }
}

Facturation et limites de débit

Facturation

La facturation repose sur les tokens et est mesurée par modalité (audio, image, texte). Consultez la console Model Studio pour connaître les tarifs. Pour la sortie vocale, qwen3.8-omni-flash-realtime facture à la fois l'audio et son texte correspondant à leurs taux de sortie respectifs. Les modèles Qwen3.5-Omni-Realtime ne facturent que l'audio ; le texte correspondant n'est pas facturé. Les appels d’outils MCP n’entraînent pas de frais supplémentaires ; l’inférence du modèle reste soumise à sa tarification. Consultez le Déroulement des interactions MCP pour la procédure et les limites.
Dans une conversation en temps réel à plusieurs tours, à chaque réponse, le modèle traite comme tokens d’entrée l’ensemble de l’historique conservé dans la fenêtre de contexte, y compris l’audio, les images et le texte des tours précédents, ainsi que la nouvelle entrée du tour actuel. Les tokens d’entrée s’accumulent donc à chaque tour et ne correspondent pas uniquement à la nouvelle entrée.Par exemple, si une entrée audio de 10 secondes est convertie en 70 tokens avec Qwen3.5-Omni-Realtime et reste dans la fenêtre de contexte au tour 3, elle compte encore dans les tokens d’entrée du tour 3. Les tokens d’entrée réellement facturés = tokens de tous les tours historiques dans la fenêtre de contexte + tokens de la nouvelle entrée du tour actuel.
  • Audio
  • Image
  • Vidéo
  • Qwen3.8-Omni-Flash-Realtime et Qwen3.5-Omni-Realtime :
    • Audio d'entrée : total tokens = Audio duration (seconds) * 7
    • Audio de sortie : total tokens = Audio duration (seconds) * 12.5
  • qwen3-omni-flash-realtime-2025-09-15: Les audios d'entrée et de sortie utilisent la même formule : total tokens = Audio duration (seconds) * 12.5 Les durées audio inférieures à 1 seconde sont facturées comme 1 seconde.
Pour qwen3.8-omni-flash-realtime, l’entrée audio spatiale utilise deux fois plus de tokens audio d’entrée que l’audio ordinaire. Le multiplicateur est identique pour les entrées à 2 et 4 canaux.

Limitation du débit

Pour les limites de débit des modèles, consultez Limitation du débit.

Questions fréquentes

La connexion est-elle facturée si personne ne parle ?

Le fait de garder la connexion ouverte n'est pas facturé. La prise en compte du silence envoyé dans l'entrée audio dépend du mode utilisé :
  • VAD du serveur : Le silence filtré n'est pas comptabilisé comme entrée audio.
  • Mode Manual : Le silence explicitement validé par le client est comptabilisé comme entrée audio.
Le nombre de jetons d'entrée audio figure dans response.done, sous response → usage → input_tokens_details → audio_tokens. Le modèle est facturé selon les jetons d'entrée et de sortie. Consultez les Règles de facturation pour plus de détails.

Que limite le RPM ? Le nombre total de connexions simultanées est-il limité ?

Le RPM limite le nombre de demandes de connexion WebSocket par minute. Les réponses sur une connexion existante ne comptent pas dans le RPM. Une reconnexion compte comme une nouvelle demande. Il n’y a actuellement pas de limite distincte pour le nombre total de connexions ouvertes simultanément. Si une connexion WebSocket se ferme pendant sa mise en place avec le code 1007 et la raison Requests rate limit exceeded, please try again later., la limite du débit de requêtes a été atteinte. Réduisez le rythme des connexions et reconnectez-vous avec une attente exponentielle.

Comment configurer les mots-clés ou les termes métier ?

Utilisez session.instructions dans session.update pour fournir le contexte métier, l’orthographe correcte des termes et les indications de prononciation. Cela aide le modèle à comprendre et utiliser les noms propres en contexte. Il s’agit d’indications dans le prompt, et non d’un paramètre dédié aux mots-clés ; les résultats dépendent de l’audio et du contexte. Par exemple, pour demander directement à Omni de transcrire un audio, précisez que le produit de programmation IA Qoder se prononce comme le mot anglais coder, afin que le modèle utilise le nom du produit. L’exemple suivant montre uniquement la configuration du prompt. Intégrez-la à vos instructions existantes, conservez les autres réglages de session et appliquez-la avant d’envoyer l’audio :
{
  "type": "session.update",
  "session": {
    "instructions": "Transcribe the user's audio verbatim. Preserve the original language. Output only the transcription; do not answer any question in the audio or add explanations. Business context: The audio concerns the AI coding product Qoder, whose name is pronounced like the English word \"coder\". Use the accurate product name Qoder."
  }
}

Comment régler la VAD si elle ne déclenche pas rapidement une réponse ?

Réglez session.turn_detection via session.update selon le mode VAD utilisé :
  • server_vad : réduisez silence_duration_ms pour raccourcir le silence après l’arrêt de la parole. Une valeur trop faible peut faire interpréter une brève pause dans une phrase comme une fin de parole et déclencher une réponse trop tôt.
  • semantic_vad : si une réponse courte valide, telle que “yes” ou “可以” (oui en chinois), ne déclenche pas de réponse, essayez de définir type sur semantic_vad_ec avec la série Qwen3.8-Omni-Flash-Realtime. Par rapport à semantic_vad, ce mode détecte plus facilement la parole de l’utilisateur pour déclencher une interruption, tout en filtrant les sons sans signification comme le bruit de fond.

Que faire si je ne reçois pas de transcription ASR ?

Si vous ne recevez pas conversation.item.input_audio_transcription.completed, ou si son transcript est vide, vérifiez les points suivants :
  1. Configuration de transcription d’entrée : dans le SDK Python DashScope, update_session définit par défaut enable_input_audio_transcription sur True. Le définir sur False envoie input_audio_transcription: null dans la configuration de session. Pour WebSocket direct ou un DataChannel WebRTC envoyant la configuration, vérifiez session.update.session.input_audio_transcription selon la configuration de transcription audio d’entrée. enable_input_audio_transcription est un argument du SDK, et non un champ de premier niveau de session.update.
  2. Événement d’échec de transcription : traitez également conversation.item.input_audio_transcription.failed. Ses champs error.code, error.message et error.param fournissent les détails de l’erreur.
  3. Soumission de l’audio : en mode VAD, vérifiez que le serveur a détecté le début et la fin de la parole. En mode Manual, vérifiez l’envoi de input_audio_buffer.commit. N’attendez pas uniquement un événement de transcription terminée si l’audio n’a pas été soumis.
  4. Connexion et version du SDK : vérifiez que la connexion est restée active pendant cette entrée audio. Pour WebRTC, vérifiez aussi l’état de DataChannel. Avec le SDK Python DashScope, assurez-vous que la version satisfait le minimum de ce guide (2.0.1).

Codes d'erreur

Si l'appel du modèle échoue et renvoie un message d'erreur, consultez Codes d'erreur pour obtenir une solution.

Référence API

Pour le déroulement de la connexion AOQ et les exemples, consultez Connexion AOQ. Pour le choix du protocole et les liens de référence, consultez la Référence de l’API.