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.
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.
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
Dieser Leitfaden verwendet Flash für die meisten Beispiele, da es der richtige Ausgangspunkt 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 primäre Weg, Qwen3.5-Omni in der Produktion zu nutzen. Sie benötigen ein DashScope-Konto und einen API-Schlüssel.
Schritt 1: Erstellen Sie ein DashScope-Konto
Gehen Sie zu dashscope.aliyuncs.com und registrieren Sie sich. Wenn Sie bereits ein Alibaba Cloud-Konto haben, verwenden Sie dieses.
Schritt 2: Holen Sie sich Ihren API-Schlüssel
- Melden Sie sich an der DashScope-Konsole an
- Klicken Sie in der linken Seitenleiste auf API Key Management
- Klicken Sie auf Create API Key
- Kopieren Sie den Schlüssel (Format:
sk-...)
Schritt 3: Installieren Sie das SDK
pip install dashscope
Oder verwenden Sie den OpenAI-kompatiblen Endpunkt direkt mit dem openai SDK:
pip install openai
DashScope stellt eine OpenAI-kompatible API unter https://dashscope.aliyuncs.com/compatible-mode/v1 bereit, was bedeutet, dass Sie Ihre base_url austauschen und denselben Code verwenden können, den Sie für OpenAI schreiben würden.
Texteingabe und -ausgabe
Beginnen Sie mit dem einfachsten Fall: 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)
Wechseln Sie zu qwen3.5-omni-plus für schwierigere Schlussfolgerungsaufgaben oder qwen3.5-omni-light, wenn Latenz die Priorität hat.
Audio-Eingabe: Transkription und Verständnis
Übergeben Sie eine Audio-Datei-URL oder base64-kodiertes Audio. Das Modell transkribiert, versteht und schlussfolgert den Inhalt nativ. Es ist kein separater ASR-Schritt erforderlich.
import base64
from openai import OpenAI
client = OpenAI(
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)
# Lokale 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)
Das Modell unterstützt 113 Sprachen für die Spracherkennung. Sie müssen die Sprache nicht angeben; es erkennt sie automatisch.
Unterstützte Audioformate: WAV, MP3, M4A, OGG, FLAC.
Audio-Ausgabe: Text-to-Speech in der Antwort
Um Sprache statt Text zurückzuerhalten, legen Sie den Parameter modalities fest 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."
}
],
)
# Die Antwort enthält sowohl Text als auch Audio
text_content = response.choices[0].message.content
audio_data = response.choices[0].message.audio.data # base64-kodiertes WAV
# Audio speichern
with open("response.wav", "wb") as f:
f.write(base64.b64decode(audio_data))
print(f"Text: {text_content}")
print("Audio gespeichert unter response.wav")
Zwei integrierte Stimmen sind verfügbar: Chelsie (weiblich) und Ethan (männlich). Die Sprachgenerierung funktioniert in 36 Sprachen.
Bildeingabe: visuelles Verständnis
Übergeben Sie eine Bild-URL oder ein base64-kodiertes Bild zusammen mit einer 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)
Für lokale Bilder kodieren Sie diese als base64:
import base64
with open("screenshot.png", "rb") as f:
image_data = base64.b64encode(f.read()).decode("utf-8")
# Daten-URL-Format verwenden
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?"
}
]
}
],
)
Video-Eingabe: Verständnis von Aufnahmen und Bildschirmaufzeichnungen
Die Video-Eingabe ist der Bereich, in dem Qwen3.5-Omni etwas tut, was kein Text- oder Bildmodell kann: über visuelle und akustische Spuren gleichzeitig schlussfolgern.
from openai import OpenAI
import base64
client = OpenAI(
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)
# Eine Video-URL übergeben
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)
Audio-visuelles Vibe-Coding
Der Anwendungsfall „Vibe Coding“ besteht darin, eine Bildschirmaufnahme zu übergeben und das Modell aufzufordern, Code aus dem Gesehenen zu generieren:
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", # Verwenden Sie Plus für die beste Code-Generierungsqualität
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)
Das 256K Token-Kontextfenster fasst ungefähr 400 Sekunden 720p-Video mit Audio. Für längere Aufnahmen kürzen oder teilen Sie diese.
Stimmklonung
Die Stimmklonung ermöglicht es Ihnen, dem Modell eine Zielstimme zu geben und es in dieser Stimme antworten zu lassen. Dies ist über die API für Plus und Flash verfügbar.
import base64
from openai import OpenAI
client = OpenAI(
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
api_key="sk-IHR_DASHSCOPE_SCHLÜSSEL",
)
# Eine 10-30 Sekunden lange Sprachprobe zum Klonen laden
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))
Tipps für die Qualität der Stimmklonung:
- Verwenden Sie eine saubere Aufnahme ohne Hintergrundgeräusche
- 15-30 Sekunden funktionieren besser als sehr kurze Clips
- WAV-Format mit 16kHz oder höher
- Die Sprachprobe sollte natürliche Sprache enthalten, nicht vorgelesenen Text, für eine bessere Prosodie-Anpassung
Streaming-Antworten
Für Echtzeit-Sprachchats oder interaktive Anwendungen verwenden Sie Streaming. Das Modell beginnt mit der Rückgabe von Audio, bevor die vollständige Antwort generiert wurde:
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
# Audio-Chunks kombinieren und speichern
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)
Das PCM16-Format eignet sich gut für das Streaming, da Sie es direkt in einen Audioausgabepuffer leiten können, ohne auf eine vollständige Datei warten zu müssen.
Konversation über mehrere Runden mit gemischten Modalitäten
Echte Unterhaltungen mischen Eingaben über verschiedene Runden hinweg. Hier erfahren Sie, wie Sie den Konversationsverlauf mit verschiedenen Modalitäten verwalten:
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: Ein Bild hinzufügen (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?"}]))
Das 256K Kontextfenster bedeutet, dass Sie lange Unterhaltungen führen können, einschließlich solcher mit eingebetteten Bildern und Audio, ohne auf Kürzungsprobleme zu stoßen.
Lokale Bereitstellung mit HuggingFace
Wenn Sie Qwen3.5-Omni auf Ihrer eigenen Infrastruktur ausführen müssen:
pip install transformers==4.57.3
pip install accelerate
pip install qwen-omni-utils -U
pip install -U flash-attn --no-build-isolation
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)
GPU-Speicheranforderungen für die lokale Bereitstellung:
| Variante | Genauigkeit | Min VRAM |
|---|---|---|
| Plus (30B MoE) | BF16 | ~40GB |
| Flash | BF16 | ~20GB |
| Light | BF16 | ~10GB |
Verwenden Sie für die lokale Inferenz in der Produktion vLLM anstelle von HuggingFace Transformers. MoE-Modelle laufen unter den Routing-Optimierungen von vLLM schneller.
Testen Ihrer Qwen3.5-Omni-Anfragen mit Apidog
Multimodale API-Anfragen sind schwieriger zu debuggen als einfaches JSON. Sie haben es mit base64-kodiertem Audio und Video, verschachtelten Inhalts-Arrays und Antworten zu tun, die sowohl Text als auch Audio enthalten können. Dies von einem Terminal aus zu tun, wird schnell mühsam.
Apidog handhabt dies sauber. Richten Sie Ihren DashScope-Endpunkt als neue Sammlung ein, speichern Sie Ihren API-Schlüssel als Umgebungsvariable und erstellen Sie Anforderungsvorlagen für jede Modalität, mit der Sie arbeiten.
Für jede Variante (Plus, Flash, Light) können Sie die Basis-Anfrage duplizieren und den Modellparameter ändern. Führen Sie alle drei nacheinander aus und vergleichen Sie Antworten, Latenz und Ausgabequalität in einer Ansicht.
Sie können in Apidog auch Testassertions schreiben, um Ihre multimodalen Antworten zu überprüfen:
- Prüfen Sie, ob
choices[0].message.contentfür Textantworten nicht leer ist - Verifizieren Sie, dass
choices[0].message.audio.datavorhanden ist, wenn Audioausgabe angefordert wird - Bestätigen Sie, dass die Antwortlatenz für Flash unter Ihrem Zielschwellenwert liegt
Dies ist nützlich, wenn Sie entscheiden, welche Variante in der Produktion verwendet werden soll.
Fehlerbehandlung und Wiederholungslogik
Ratenbegrenzungen und Timeouts sind bei großen multimodalen Modellen üblich, insbesondere bei Videoeingaben. Bauen Sie von Anfang an eine Wiederholungslogik 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, # 2-Minuten-Timeout für große Videoeingaben
)
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")
Für Videoeingaben größer als 100 MB sollten Sie Folgendes beachten:
- Trimmen auf den relevanten Teil vor dem Senden
- Reduzierung der Auflösung auf 480p, wenn der visuelle Inhalt keine hohe Auflösung erfordert
- Aufteilen langer Aufnahmen in Segmente und Aggregation der Ergebnisse
Häufige Probleme und Lösungen
„Die Audioausgabe ist bei Zahlen oder Fachbegriffen verzerrt“Dies ist das Problem, das die ARIA-Technologie angeht. Stellen Sie sicher, dass Sie Qwen3.5-Omni (nicht eine frühere Version) verwenden. Wenn Sie selbst hosten, verwenden Sie die neuesten Modellgewichte von HuggingFace.
„Das Modell redet weiter, wenn ich eine Audio-Unterbrechung sende“Semantische Unterbrechung erfordert die Flash- oder Plus-Variante. Light verfügt möglicherweise nicht über diese Funktion. Prüfen Sie auch, ob Sie die Antwort streamen (nicht im Batch), damit die Unterbrechung funktioniert.
„Die Qualität des Stimmklonens ist schlecht“Die Sprachprobe muss sauber sein. Entfernen Sie Hintergrundgeräusche mit einem Tool wie Audacity, bevor Sie sie hochladen. Verwenden Sie mindestens 15 Sekunden Audio. WAV mit 16 kHz oder 44,1 kHz funktioniert am besten.
„Videoeingabe gibt einen Fehler bezüglich Token-Limits zurück“256K Token decken ungefähr 400 Sekunden 720p-Video ab. Längere Videos müssen gekürzt oder in geringerer Auflösung vorliegen. Überprüfen Sie Ihre Videodauer und reduzieren Sie sie zur Sicherheit auf unter 6 Minuten.
„Lokale Bereitstellung ist sehr langsam“Verwenden Sie vLLM, nicht HuggingFace Transformers, für die lokale Inferenz in der Produktion. MoE-Modelle benötigen vLLMs Routing-Optimierungen für einen angemessenen Durchsatz.
FAQ
Welche DashScope-Modell-ID verwende ich für Qwen3.5-Omni?
Verwenden Sie qwen3.5-omni-plus, qwen3.5-omni-flash oder qwen3.5-omni-light, je nach Ihren Anforderungen an Qualität und Latenz. Beginnen Sie mit Flash für die meisten Anwendungsfälle.
Kann ich das OpenAI Python SDK mit DashScope verwenden?
Ja. Setzen Sie base_url="https://dashscope.aliyuncs.com/compatible-mode/v1" und verwenden Sie Ihren DashScope-Schlüssel als api_key. Das Anfrage- und Antwortformat ist identisch mit der OpenAI API.
Wie sende ich mehrere Dateien (Audio + Bild) in einer Anfrage?
Fügen Sie sie dem content-Array als separate typisierte Objekte neben Ihrem Text-Prompt hinzu. Alle vier Modalitäten können in derselben Nachricht erscheinen.
Gibt es eine Größenbeschränkung für Audio- oder Videodateien?
DashScope hat Payload-Limits pro Anfrage. Für große Dateien verwenden Sie eine URL-Referenz anstelle von Base64-Kodierung. Hostet die Datei auf zugänglichem Speicher und übergeben Sie die URL im audio- oder video_url-Feld.
Wie deaktiviere ich die Audioausgabe und erhalte nur Text?
Setzen Sie modalities=["text"] oder lassen Sie den Parameter modalities weg. Nur-Text-Antworten sind schneller und günstiger.
Unterstützt es Funktions-/Tool-Aufrufe?
Ja. Verwenden Sie den Standardparameter tools mit Funktionsdefinitionen, genau wie bei jedem OpenAI-kompatiblen Modell. Das Modell gibt strukturierte Tool-Aufrufobjekte zurück, die Sie in Ihrem eigenen Code ausführen.
Was ist der beste Weg, um lange Audioaufnahmen zu verarbeiten?
Für Aufnahmen unter 10 Stunden senden Sie diese als eine einzige Anfrage. Bei längeren Aufnahmen teilen Sie diese an natürlichen Pausenpunkten auf und verarbeiten jedes Segment separat. Aggregieren Sie die Ergebnisse in Ihrer Anwendungsschicht.
Wie teste ich meine multimodalen Anfragen, bevor ich eine vollständige Anwendung erstelle?
Verwenden Sie Apidog, um Anforderungs-Templates für jede Modalität zu erstellen und zu speichern. Sie können zwischen Modellvarianten wechseln, die vollständige Antwortstruktur überprüfen und Assertions schreiben, die die Ausgabequalität überprüfen, ohne zuerst Anwendungscode schreiben zu müssen.