DEV Community

Cover image for Qwen3.5-Omni nutzen: Text, Audio, Video & Stimmklonierung per API
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

Qwen3.5-Omni nutzen: Text, Audio, Video & Stimmklonierung per API

#ai #api #llm #tutorial

Kurz gesagt

Qwen3.5-Omni akzeptiert Text, Bilder, Audio und Video als Eingabe und gibt Text oder Echtzeit-Sprache zurück. Greifen Sie über die Alibaba Cloud DashScope API darauf zu oder führen Sie es lokal über HuggingFace Transformers aus. Dieser Leitfaden behandelt die API-Einrichtung, funktionierende Codebeispiele für jede Modalität, Stimmklonung und wie Sie Ihre Anfragen mit Apidog testen können.

Teste Apidog noch heute

Womit Sie arbeiten

Qwen3.5-Omni ist ein einzelnes Modell, das vier Eingabetypen gleichzeitig verarbeitet: Text, Bilder, Audio und Video. Es gibt entweder Text oder natürliche Sprache zurück, je nachdem, wie Sie die Anfrage konfigurieren.

Qwen3.5-Omni Übersicht

Es wurde am 30. März 2026 veröffentlicht und basiert auf einer Thinker-Talker-Architektur mit einem MoE-Backbone. Der Thinker verarbeitet multimodale Eingaben und führt darauf Schlussfolgerungen aus. Der Talker wandelt die Ausgabe mithilfe eines Multi-Codebook-Systems in Sprache um, das Audio-Streaming beginnt, bevor die vollständige Antwort vorliegt.

Drei Varianten sind verfügbar:

  • Plus: Höchste Qualität, am besten für Schlussfolgerungen und Stimmklonung
  • Flash: Ausgewogene Geschwindigkeit und Qualität, empfohlen für die meisten Produktionsanwendungen
  • Light: Geringste Latenz, für mobile und Edge-Szenarien

Für diesen Leitfaden wird Flash verwendet, da es ein guter Startpunkt für die meisten Anwendungen ist. Ersetzen Sie Plus dort, wo Sie maximale Qualität benötigen.

API-Zugriff über DashScope

Die DashScope API von Alibaba Cloud ist der Standardweg, Qwen3.5-Omni produktiv zu nutzen. Sie benötigen dazu ein DashScope-Konto und einen API-Schlüssel.

Schritt 1: DashScope-Konto erstellen

Registrieren Sie sich unter dashscope.aliyuncs.com. Falls Sie ein Alibaba Cloud-Konto besitzen, können Sie dieses verwenden.

Schritt 2: API-Schlüssel generieren

  1. Melden Sie sich an der DashScope-Konsole an
  2. Klicken Sie in der linken Seitenleiste auf API Key Management
  3. Klicken Sie auf Create API Key
  4. Kopieren Sie den Schlüssel (Format: sk-...)

Schritt 3: SDK installieren 

pip install dashscope
Enter fullscreen mode Exit fullscreen mode

Alternativ: Verwenden Sie den OpenAI-kompatiblen Endpunkt direkt mit dem openai SDK:

pip install openai
Enter fullscreen mode Exit fullscreen mode

DashScope bietet eine OpenAI-kompatible API unter https://dashscope.aliyuncs.com/compatible-mode/v1. Sie können Ihre base_url einfach austauschen und den gleichen Code wie für OpenAI nutzen.

Texteingabe und -ausgabe

Starten Sie mit dem Standardfall: Text rein, Text raus.

from openai import OpenAI

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)

response = client.chat.completions.create(
    model="qwen3.5-omni-flash",
    messages=[
        {
            "role": "user",
            "content": "Erklären Sie den Unterschied zwischen REST- und GraphQL-APIs in einfachen Worten."
        }
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Für anspruchsvollere Aufgaben wechseln Sie zu qwen3.5-omni-plus oder nutzen Sie qwen3.5-omni-light, wenn Latenz wichtig ist.

Audio-Eingabe: Transkription und Verständnis

Übergeben Sie eine Audiodatei als URL oder base64-kodiert. Das Modell transkribiert und versteht den Inhalt nativ – kein separater ASR-Schritt notwendig.

import base64
from openai import OpenAI

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)

# Audiodatei laden
with open("meeting_recording.wav", "rb") as f:
    audio_data = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="qwen3.5-omni-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_audio",
                    "input_audio": {
                        "data": audio_data,
                        "format": "wav"
                    }
                },
                {
                    "type": "text",
                    "text": "Fassen Sie die wichtigsten Entscheidungen dieses Meetings zusammen und listen Sie alle Aktionspunkte auf."
                }
            ]
        }
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode
  • Das Modell erkennt 113 Sprachen automatisch.
  • Unterstützte Audioformate: WAV, MP3, M4A, OGG, FLAC.

Audio-Ausgabe: Text-to-Speech in der Antwort

Sie möchten Sprache statt Text? Setzen Sie den Parameter modalities und konfigurieren Sie die Audioausgabe:

from openai import OpenAI
import base64

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)

response = client.chat.completions.create(
    model="qwen3.5-omni-flash",
    modalities=["text", "audio"],
    audio={"voice": "Chelsie", "format": "wav"},
    messages=[
        {
            "role": "user",
            "content": "Beschreiben Sie die Schritte zur Authentifizierung einer REST-API mit OAuth 2.0."
        }
    ],
)

text_content = response.choices[0].message.content
audio_data = response.choices[0].message.audio.data

with open("response.wav", "wb") as f:
    f.write(base64.b64decode(audio_data))

print(f"Text: {text_content}")
print("Audio gespeichert unter response.wav")
Enter fullscreen mode Exit fullscreen mode
  • Stimmen: Chelsie (weiblich), Ethan (männlich).
  • Sprachgenerierung in 36 Sprachen.

Bildeingabe: Visuelles Verständnis

Übergeben Sie eine Bild-URL oder ein base64-kodiertes Bild plus Textfrage:

from openai import OpenAI

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)

response = client.chat.completions.create(
    model="qwen3.5-omni-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/api-diagram.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Beschreiben Sie dieses API-Architekturdiagramm und identifizieren Sie potenzielle Engpässe."
                }
            ]
        }
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Lokale Bilder als base64 kodieren:

import base64

with open("screenshot.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode("utf-8")

image_url = f"data:image/png;base64,{image_data}"

response = client.chat.completions.create(
    model="qwen3.5-omni-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": image_url}
                },
                {
                    "type": "text",
                    "text": "Welcher Fehler wird in diesem Screenshot angezeigt?"
                }
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Video-Eingabe: Verständnis von Aufnahmen und Bildschirmaufzeichnungen

Qwen3.5-Omni kann Video und Audio gleichzeitig analysieren.

from openai import OpenAI
import base64

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)

response = client.chat.completions.create(
    model="qwen3.5-omni-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://example.com/product-demo.mp4"
                    }
                },
                {
                    "type": "text",
                    "text": "Beschreiben Sie, was der Entwickler in dieser Demo erstellt, und schreiben Sie den äquivalenten Code."
                }
            ]
        }
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Audio-visuelles Vibe-Coding

Übergeben Sie eine Bildschirmaufnahme und generieren Sie Code:

with open("screen_recording.mp4", "rb") as f:
    video_data = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="qwen3.5-omni-plus",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "video_url",
                    "video_url": {
                        "url": f"data:video/mp4;base64,{video_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Sehen Sie sich diese Bildschirmaufnahme an und schreiben Sie den vollständigen Code, der repliziert, was Sie beim Erstellen sehen. Fügen Sie alle UI-Komponenten und deren Interaktionen ein."
                }
            ]
        }
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Das 256K Token-Kontextfenster reicht für ca. 400 Sekunden 720p-Video mit Audio. Für längere Videos: Aufteilen oder kürzen.

Stimmklonung

Geben Sie dem Modell eine Sprachprobe, um die Antwort in dieser Stimme zu erhalten. Funktioniert mit Plus und Flash:

import base64
from openai import OpenAI

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)

with open("voice_sample.wav", "rb") as f:
    voice_sample = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="qwen3.5-omni-plus",
    modalities=["text", "audio"],
    audio={
        "voice": "custom",
        "format": "wav",
        "voice_sample": {
            "data": voice_sample,
            "format": "wav"
        }
    },
    messages=[
        {
            "role": "user",
            "content": "Willkommen im Apidog Entwicklerportal. Wie kann ich Ihnen heute helfen?"
        }
    ],
)

audio_data = response.choices[0].message.audio.data
with open("cloned_response.wav", "wb") as f:
    f.write(base64.b64decode(audio_data))
Enter fullscreen mode Exit fullscreen mode

Tipps:

  • Nur saubere Aufnahmen ohne Hintergrundgeräusche verwenden
  • 15-30 Sekunden Länge
  • WAV mit 16kHz oder höher
  • Natürliche Sprache für beste Prosodie

Streaming-Antworten

Für Echtzeit-Sprachchats: Nutzen Sie Streaming, um Audio zu erhalten, bevor die Antwort fertig ist.

from openai import OpenAI

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)

stream = client.chat.completions.create(
    model="qwen3.5-omni-flash",
    modalities=["text", "audio"],
    audio={"voice": "Ethan", "format": "pcm16"},
    messages=[
        {
            "role": "user",
            "content": "Erklären Sie, wie sich WebSocket-Verbindungen von HTTP-Polling unterscheiden."
        }
    ],
    stream=True,
)

audio_chunks = []
text_chunks = []

for chunk in stream:
    delta = chunk.choices[0].delta
    if hasattr(delta, "audio") and delta.audio:
        if delta.audio.get("data"):
            audio_chunks.append(delta.audio["data"])
    if delta.content:
        text_chunks.append(delta.content)
        print(delta.content, end="", flush=True)

print()  # Zeilenumbruch nach Streaming-Text

if audio_chunks:
    import base64
    full_audio = b"".join(base64.b64decode(chunk) for chunk in audio_chunks)
    with open("streamed_response.pcm", "wb") as f:
        f.write(full_audio)
Enter fullscreen mode Exit fullscreen mode

PCM16 eignet sich perfekt fürs Streaming (direkte Weitergabe an den Audioausgabepuffer möglich).

Konversation über mehrere Runden mit gemischten Modalitäten

So verwalten Sie Konversationsverläufe mit mehreren Modalitäten:

from openai import OpenAI

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)

conversation = []

def send_message(content_parts):
    conversation.append({"role": "user", "content": content_parts})

    response = client.chat.completions.create(
        model="qwen3.5-omni-flash",
        messages=conversation,
    )

    reply = response.choices[0].message.content
    conversation.append({"role": "assistant", "content": reply})
    return reply

# Runde 1: Text
print(send_message([{"type": "text", "text": "Ich habe eine API, die immer 503-Fehler zurückgibt."}]))

# Runde 2: Bild (Screenshot des Fehlerprotokolls)
import base64
with open("error_log.png", "rb") as f:
    img = base64.b64encode(f.read()).decode()

print(send_message([
    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img}"}},
    {"type": "text", "text": "Hier ist der Screenshot des Fehlerprotokolls. Was verursacht das?"}
]))

# Runde 3: Nachfolgender Text
print(send_message([{"type": "text", "text": "Wie behebe ich die von Ihnen erwähnte Erschöpfung des Verbindungspools?"}]))
Enter fullscreen mode Exit fullscreen mode

Mit 256K Kontextfenster sind auch lange Gespräche mit Bildern oder Audio problemlos möglich.

Lokale Bereitstellung mit HuggingFace

Führen Sie Qwen3.5-Omni auf eigener Hardware aus:

pip install transformers==4.57.3
pip install accelerate
pip install qwen-omni-utils -U
pip install -U flash-attn --no-build-isolation
Enter fullscreen mode Exit fullscreen mode 
import soundfile as sf
from transformers import Qwen3OmniMoeForConditionalGeneration, Qwen3OmniMoeProcessor
from qwen_omni_utils import process_mm_info

model_path = "Qwen/Qwen3-Omni-30B-A3B-Instruct"

model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
    model_path,
    device_map="auto",
    attn_implementation="flash_attention_2",
)
processor = Qwen3OmniMoeProcessor.from_pretrained(model_path)

conversation = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "Sie sind Qwen, ein virtueller Mensch, entwickelt vom Qwen Team, Alibaba Group, fähig zur Wahrnehmung auditiver und visueller Eingaben, sowie zur Generierung von Text und Sprache."}
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "audio", "audio": "path/to/your/audio.wav"},
            {"type": "text", "text": "Was wird in diesem Audio besprochen?"}
        ],
    },
]

text = processor.apply_chat_template(
    conversation,
    add_generation_prompt=True,
    tokenize=False,
)
audios, images, videos = process_mm_info(conversation, use_audio_in_video=True)
inputs = processor(
    text=text,
    audio=audios,
    images=images,
    videos=videos,
    return_tensors="pt",
    padding=True,
)
inputs = inputs.to(model.device).to(model.dtype)

text_ids, audio_output = model.generate(**inputs, speaker="Chelsie")

text_response = processor.batch_decode(text_ids, skip_special_tokens=True)[0]
sf.write("local_response.wav", audio_output.reshape(-1).cpu().numpy(), samplerate=24000)

print(text_response)
Enter fullscreen mode Exit fullscreen mode

GPU-Anforderungen:

Variante Genauigkeit Min VRAM
Plus (30B MoE) BF16 ~40GB
Flash BF16 ~20GB
Light BF16 ~10GB

Für Produktion empfiehlt sich vLLM statt HuggingFace Transformers, da MoE-Modelle mit vLLM schneller laufen.

Testen Ihrer Qwen3.5-Omni-Anfragen mit Apidog

Multimodale API-Anfragen sind komplexer als einfaches JSON. Sie haben es mit base64-kodiertem Audio/Video, verschachtelten Arrays und multimodalen Antworten zu tun. Das Testen im Terminal ist mühselig.

Apidog Screenshot

Apidog macht dies effizient: Legen Sie Ihren DashScope-Endpunkt als neue Sammlung an, speichern Sie den API-Schlüssel als Umgebungsvariable und erstellen Sie Anforderungsvorlagen für jede Modalität.

Für jede Variante (Plus, Flash, Light) können Sie die Anfrage duplizieren und nur den Modellparameter ändern. Führen Sie alle Varianten direkt nacheinander aus und vergleichen Sie die Ausgaben und Latenz.

Sie können Testassertions in Apidog schreiben, um multimodale Antworten zu prüfen:

  • Ist choices[0].message.content für Textantworten nicht leer?
  • Ist choices[0].message.audio.data vorhanden, wenn Audio angefordert wurde?
  • Liegt die Antwortlatenz für Flash unter dem Zielwert?

So finden Sie die beste Modellvariante für Ihre Produktion.

Fehlerbehandlung und Wiederholungslogik

Ratenbegrenzungen und Timeouts sind bei großen multimodalen Modellen häufig, besonders bei Videoeingaben. Bauen Sie Wiederholungslogik direkt ein:

import time
import random
from openai import OpenAI, RateLimitError, APITimeoutError, APIConnectionError

client = OpenAI(
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
    timeout=120,
)

def call_with_retry(messages, model="qwen3.5-omni-flash", max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model=model,
                messages=messages,
            )
        except RateLimitError:
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"Ratenbegrenzung erreicht. Warte {wait:.1f}s...")
            time.sleep(wait)
        except (APITimeoutError, APIConnectionError) as e:
            if attempt == max_retries - 1:
                raise
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"Verbindungsfehler: {e}. Wiederhole in {wait:.1f}s...")
            time.sleep(wait)
    raise RuntimeError(f"Fehlgeschlagen nach {max_retries} Versuchen")
Enter fullscreen mode Exit fullscreen mode

Für Videoeingaben > 100 MB:

  • Schneiden Sie die Datei auf den relevanten Teil
  • Reduzieren Sie die Auflösung auf 480p, falls hohe Qualität nicht nötig ist
  • Teilen Sie lange Aufnahmen in Segmente und aggregieren Sie die Ergebnisse

Häufige Probleme und Lösungen

„Die Audioausgabe ist bei Zahlen oder Fachbegriffen verzerrt“

Nutzen Sie Qwen3.5-Omni (nicht ältere Versionen). Bei Self-Hosting: neueste Modellgewichte verwenden.

„Das Modell redet weiter, wenn ich eine Audio-Unterbrechung sende“

Semantische Unterbrechung erfordert Flash oder Plus. Light kann dies eventuell nicht. Nutzen Sie Streaming statt Batch.

„Die Qualität des Stimmklonens ist schlecht“

Sprachprobe säubern (z.B. mit Audacity), mind. 15 Sekunden, WAV 16kHz oder 44,1kHz.

„Videoeingabe gibt einen Fehler bezüglich Token-Limits zurück“

256K Token ≈ 400 Sekunden 720p-Video. Kürzen Sie längere Videos oder verringern Sie die Auflösung.

„Lokale Bereitstellung ist sehr langsam“

vLLM statt HuggingFace Transformers nutzen, da MoE-Modelle mit vLLM optimiert laufen.

FAQ

Welche DashScope-Modell-ID verwende ich für Qwen3.5-Omni?

Nutzen Sie qwen3.5-omni-plus, qwen3.5-omni-flash oder qwen3.5-omni-light je nach Qualitäts- und Latenzbedarf. Flash ist für die meisten Anwendungsfälle optimal.

Kann ich das OpenAI Python SDK mit DashScope verwenden?

Ja, mit base_url="https://dashscope.aliyuncs.com/compatible-mode/v1" und Ihrem DashScope-Schlüssel als api_key. Das API-Format ist identisch zu OpenAI.

Wie sende ich mehrere Dateien (Audio + Bild) in einer Anfrage?

Fügen Sie jede Modalität als eigenes typisiertes Objekt ins content-Array ein. Alle vier Modalitäten können kombiniert werden.

Gibt es eine Größenbeschränkung für Audio- oder Videodateien?

DashScope limitiert die Payload pro Anfrage. Für große Dateien nutzen Sie eine URL statt Base64. Hosten Sie die Datei und übergeben Sie die URL.

Wie deaktiviere ich die Audioausgabe und erhalte nur Text?

Setzen Sie modalities=["text"] oder lassen Sie den Parameter weg. Nur-Text ist schneller und günstiger.

Unterstützt es Funktions-/Tool-Aufrufe?

Ja. Nutzen Sie den Parameter tools mit Funktionsdefinitionen. Antworten kommen als strukturierte Tool-Call-Objekte zurück.

Was ist der beste Weg, um lange Audioaufnahmen zu verarbeiten?

Unter 10 Stunden: als einzelne Anfrage senden. Für mehr: an sinnvollen Pausenpunkten teilen und Segmente einzeln verarbeiten.

Wie teste ich meine multimodalen Anfragen, bevor ich eine vollständige Anwendung erstelle?

Nutzen Sie Apidog, um Vorlagen für jede Modalität zu speichern, Modellvarianten direkt zu vergleichen und Assertions zur Ausgabequalität zu schreiben – ganz ohne eigenen Anwendungscode.

Top comments (0)