Modelle

Flaggschiffmodelle

Text to Speech

Speech to Text

Voice Agents

Musik

Modellübersicht

Die ElevenLabs API bietet eine Reihe von Audiomodellen, die für unterschiedliche Anwendungsfälle, Qualitätsstufen und Leistungsanforderungen optimiert sind.

Veraltete Modelle

Eleven v4

Eleven v4 ist unser hochmodernes Sprachsynthesemodell und liefert Audio in höchster Qualität, Ausdrucksstärke und Kontrolle über die Darbietung von Stimmen. Eleven v4 unterstützt KI-Stimme klonen in hoher Qualität mit zuverlässigem Erhalt der Sprecheridentität über lange Textgenerierungen hinweg.

Dieses Modell eignet sich gut für folgende Szenarien:

• Charakter-Voiceovers: Ideal für Spiele und Animationen dank seiner emotionalen Bandbreite.
• Emotionale Dialoge: Erstellen Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und kontextuellem Verständnis.
• Hörbuchproduktion: Perfekt für lange Erzählungen mit komplexer emotionaler Darbietung.
• Mehrsprachige Projekte: Erhält eine konsistente Stimmqualität bei Sprachwechseln.

Eleven v4 ist über die Text to Dialogue API verfügbar.

Unterstützte Sprachen

Die Modellfamilie Eleven v4 unterstützt über 90 Sprachen, darunter:

Afrikaans (af), Arabisch (ar), Armenisch (hy), Assamesisch (as), Asturisch (ast), Aserbaidschanisch (az), Belarussisch (be), Bengalisch (bn), Bosnisch (bs), Bulgarisch (bg), Birmanisch (my), Kantonesisch (yue), Katalanisch (ca), Cebuano (ceb), Kroatisch (hr), Tschechisch (cs), Dänisch (da), Niederländisch (nl), Englisch (en), Estnisch (et), Filipino (fil), Finnisch (fi), Französisch (fr), Galicisch (gl), Georgisch (ka), Deutsch (de), Griechisch (el), Gujarati (gu), Hausa (ha), Hebräisch (he), Hindi (hi), Ungarisch (hu), Isländisch (is), Indonesisch (id), Irisch (ga), Italienisch (it), Japanisch (ja), Javanisch (jv), Kannada (kn), Kasachisch (kk), Koreanisch (ko), Kirgisisch (ky), Lettisch (lv), Lingala (ln), Litauisch (lt), Luxemburgisch (lb), Mazedonisch (mk), Malaiisch (ms), Malayalam (ml), Maltesisch (mt), Mandarin-Chinesisch (zh), Māori (mi), Marathi (mr), Mongolisch (mn), Nepali (ne), Norwegisch (no), Okzitanisch (oc), Odia (or), Paschtunisch (ps), Persisch (fa), Polnisch (pl), Portugiesisch (pt), Punjabi (pa), Rumänisch (ro), Russisch (ru), Serbisch (sr), Sindhi (sd), Slowakisch (sk), Slowenisch (sl), Somali (so), Spanisch (es), Suaheli (sw), Schwedisch (sv), Tadschikisch (tg), Tamil (ta), Telugu (te), Thailändisch (th), Türkisch (tr), Ukrainisch (uk), Urdu (ur), Usbekisch (uz), Vietnamesisch (vi), Walisisch (cy), Yoruba (yo).

Eleven v4 Turbo

Eleven v4 Turbo ist unser hochmodernes Modell für Sprachsynthese in Echtzeit und liefert Audio in hoher Qualität, Ausdrucksstärke und Kontrolle über die Darbietung von Stimmen. Eleven v4 Turbo unterstützt KI-Stimme klonen in hoher Qualität und liefert Ergebnisse mit einer medianen Inferenzlatenz von ~100 ms.

Dieses Modell eignet sich gut für folgende Szenarien:

• Support-Agenten: Betreiben Sie Sprachagenten, die Kundenanfragen in Echtzeit lösen.
• KI-Assistenten: Erstellen Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und kontextuellem Verständnis.
• Interaktive Charaktere: Hervorragend für Audioerlebnisse mit ausdrucksstarken Charakteren.

Eleven v4 Turbo ist über den Text to Dialogue WebSocket verfügbar.

Unterstützte Sprachen

Die Modellfamilie Eleven v4 unterstützt über 90 Sprachen, darunter:

Afrikaans (af), Arabisch (ar), Armenisch (hy), Assamesisch (as), Asturisch (ast), Aserbaidschanisch (az), Belarussisch (be), Bengalisch (bn), Bosnisch (bs), Bulgarisch (bg), Birmanisch (my), Kantonesisch (yue), Katalanisch (ca), Cebuano (ceb), Kroatisch (hr), Tschechisch (cs), Dänisch (da), Niederländisch (nl), Englisch (en), Estnisch (et), Filipino (fil), Finnisch (fi), Französisch (fr), Galicisch (gl), Georgisch (ka), Deutsch (de), Griechisch (el), Gujarati (gu), Hausa (ha), Hebräisch (he), Hindi (hi), Ungarisch (hu), Isländisch (is), Indonesisch (id), Irisch (ga), Italienisch (it), Japanisch (ja), Javanisch (jv), Kannada (kn), Kasachisch (kk), Koreanisch (ko), Kirgisisch (ky), Lettisch (lv), Lingala (ln), Litauisch (lt), Luxemburgisch (lb), Mazedonisch (mk), Malaiisch (ms), Malayalam (ml), Maltesisch (mt), Mandarin-Chinesisch (zh), Māori (mi), Marathi (mr), Mongolisch (mn), Nepali (ne), Norwegisch (no), Okzitanisch (oc), Odia (or), Paschtunisch (ps), Persisch (fa), Polnisch (pl), Portugiesisch (pt), Punjabi (pa), Rumänisch (ro), Russisch (ru), Serbisch (sr), Sindhi (sd), Slowakisch (sk), Slowenisch (sl), Somali (so), Spanisch (es), Suaheli (sw), Schwedisch (sv), Tadschikisch (tg), Tamil (ta), Telugu (te), Thailändisch (th), Türkisch (tr), Ukrainisch (uk), Urdu (ur), Usbekisch (uz), Vietnamesisch (vi), Walisisch (cy), Yoruba (yo).

Eleven v3

Eleven v3 ist unser Sprachsynthesemodell der vorherigen Generation. Es erzeugt natürliche, lebensechte Sprache mit großer emotionaler Bandbreite und kontextuellem Verständnis in mehreren Sprachen.

Mit Eleven v3 kommt eine neue Text to Dialogue API, mit der Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und kontextuellem Verständnis in mehreren Sprachen erstellen können. Eleven v3 kann auch mit der Text to Speech API verwendet werden, um natürliche, lebensechte Sprache mit großer emotionaler Bandbreite und kontextuellem Verständnis in mehreren Sprachen zu erzeugen.

Lesen Sie hier mehr über die Text to Dialogue API.

Unterstützte Sprachen

Das Modell Eleven v3 unterstützt über 70 Sprachen, darunter:

Afrikaans (af), Arabisch (ar), Armenisch (hy), Assamesisch (as), Asturisch (ast), Aserbaidschanisch (az), Belarussisch (be), Bengalisch (bn), Bosnisch (bs), Bulgarisch (bg), Birmanisch (my), Kantonesisch (yue), Katalanisch (ca), Cebuano (ceb), Chichewa (ny), Kroatisch (hr), Tschechisch (cs), Dänisch (da), Niederländisch (nl), Englisch (en), Estnisch (et), Filipino (fil), Finnisch (fi), Französisch (fr), Galicisch (gl), Georgisch (ka), Deutsch (de), Griechisch (el), Gujarati (gu), Hausa (ha), Hebräisch (he), Hindi (hi), Ungarisch (hu), Isländisch (is), Indonesisch (id), Irisch (ga), Italienisch (it), Japanisch (ja), Javanisch (jv), Kannada (kn), Kasachisch (kk), Kirgisisch (ky), Koreanisch (ko), Lettisch (lv), Lingala (ln), Litauisch (lt), Luxemburgisch (lb), Mazedonisch (mk), Malaiisch (ms), Malayalam (ml), Maltesisch (mt), Mandarin-Chinesisch (zh), Māori (mi), Marathi (mr), Mongolisch (mn), Nepali (ne), Norwegisch (no), Okzitanisch (oc), Odia (or), Paschtunisch (ps), Persisch (fa), Polnisch (pl), Portugiesisch (pt), Punjabi (pa), Rumänisch (ro), Russisch (ru), Serbisch (sr), Sindhi (sd), Slowakisch (sk), Slowenisch (sl), Somali (so), Spanisch (es), Suaheli (sw), Schwedisch (sv), Tadschikisch (tg), Tamil (ta), Telugu (te), Thailändisch (th), Türkisch (tr), Ukrainisch (uk), Urdu (ur), Usbekisch (uz), Vietnamesisch (vi), Walisisch (cy), Yoruba (yo).

Eleven v3 Conversational

Eleven v3 Conversational ist unser Modell der vorherigen Generation für Sprachsynthese in Echtzeit. Es erzeugt natürliche, lebensechte Sprache mit großer emotionaler Bandbreite und kontextuellem Verständnis in mehreren Sprachen.

Mit Eleven v3 Conversational kommt ein neuer Text to Dialogue WebSocket, mit dem Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und kontextuellem Verständnis in mehreren Sprachen erstellen können.

Mit Eleven v3 Conversational kommt ein neuer Text to Dialogue WebSocket, mit dem Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und kontextuellem Verständnis in mehreren Sprachen erstellen können.

Lesen Sie hier mehr über den Text to Dialogue WebSocket.

Unterstützte Sprachen

Das Modell Eleven v3 unterstützt über 70 Sprachen, darunter:

Afrikaans (af), Arabisch (ar), Armenisch (hy), Assamesisch (as), Asturisch (ast), Aserbaidschanisch (az), Belarussisch (be), Bengalisch (bn), Bosnisch (bs), Bulgarisch (bg), Birmanisch (my), Kantonesisch (yue), Katalanisch (ca), Cebuano (ceb), Chichewa (ny), Kroatisch (hr), Tschechisch (cs), Dänisch (da), Niederländisch (nl), Englisch (en), Estnisch (et), Filipino (fil), Finnisch (fi), Französisch (fr), Galicisch (gl), Georgisch (ka), Deutsch (de), Griechisch (el), Gujarati (gu), Hausa (ha), Hebräisch (he), Hindi (hi), Ungarisch (hu), Isländisch (is), Indonesisch (id), Irisch (ga), Italienisch (it), Japanisch (ja), Javanisch (jv), Kannada (kn), Kasachisch (kk), Kirgisisch (ky), Koreanisch (ko), Lettisch (lv), Lingala (ln), Litauisch (lt), Luxemburgisch (lb), Mazedonisch (mk), Malaiisch (ms), Malayalam (ml), Maltesisch (mt), Mandarin-Chinesisch (zh), Māori (mi), Marathi (mr), Mongolisch (mn), Nepali (ne), Norwegisch (no), Okzitanisch (oc), Odia (or), Paschtunisch (ps), Persisch (fa), Polnisch (pl), Portugiesisch (pt), Punjabi (pa), Rumänisch (ro), Russisch (ru), Serbisch (sr), Sindhi (sd), Slowakisch (sk), Slowenisch (sl), Somali (so), Spanisch (es), Suaheli (sw), Schwedisch (sv), Tadschikisch (tg), Tamil (ta), Telugu (te), Thailändisch (th), Türkisch (tr), Ukrainisch (uk), Urdu (ur), Usbekisch (uz), Vietnamesisch (vi), Walisisch (cy), Yoruba (yo).

Multilingual v2

Eleven Multilingual v2 ist ein emotional sensibles Sprachsynthesemodell der vorherigen Generation. Es erzeugt natürliche, lebensechte Sprache mit großer emotionaler Bandbreite und kontextuellem Verständnis in mehreren Sprachen.

Das Modell liefert über alle unterstützten Sprachen hinweg eine konsistente Stimmqualität und Persönlichkeit und bewahrt dabei die einzigartigen Eigenschaften und den Akzent des Sprechers.

Dieses Modell überzeugt besonders bei Szenarien, die hochwertige, emotional nuancierte Sprache erfordern:

• Charakter-Voiceovers: Ideal für Spiele und Animationen dank seiner emotionalen Bandbreite.
• Professionelle Inhalte: Gut geeignet für Unternehmensvideos und E-Learning-Materialien.
• Mehrsprachige Projekte: Erhält eine konsistente Stimmqualität bei Sprachwechseln.
• Stabile Qualität: Erzeugt konsistente Audioausgabe in hoher Qualität.

Es hat zwar eine höhere Latenz und höhere Kosten pro Zeichen als Flash-Modelle, liefert jedoch bessere Qualität für Projekte, bei denen lebensechte Sprache wichtig ist.

Unsere mehrsprachigen v2-Modelle unterstützen 29 Sprachen:

Englisch (USA, UK, Australien, Kanada), Japanisch, Chinesisch, Deutsch, Hindi, Französisch (Frankreich, Kanada), Koreanisch, Portugiesisch (Brasilien, Portugal), Italienisch, Spanisch (Spanien, Mexiko), Indonesisch, Niederländisch, Türkisch, Filipino, Polnisch, Schwedisch, Bulgarisch, Rumänisch, Arabisch (Saudi-Arabien, VAE), Tschechisch, Griechisch, Finnisch, Kroatisch, Malaiisch, Slowakisch, Dänisch, Tamil, Ukrainisch & Russisch.

Flash v2.5

Eleven Flash v2.5 ist unser schnellstes Sprachsynthesemodell, entwickelt für Echtzeitanwendungen und die Agents Platform. Es liefert hochwertige Sprache mit extrem niedriger Latenz (~75 ms†) in 32 Sprachen.

Das Modell vereint Geschwindigkeit und Qualität. Damit eignet es sich ideal für interaktive Anwendungen und bewahrt zugleich eine natürlich klingende Ausgabe sowie konsistente Stimmeigenschaften über verschiedene Sprachen hinweg.

Dieses Modell eignet sich besonders für:

• Agents Platform: Perfekt für Sprachagenten und Chatbots in Echtzeit.
• Interaktive Anwendungen: Ideal für Spiele und Anwendungen, die sofortige Reaktionen erfordern.
• Verarbeitung im großen Maßstab: Effizient für die Text-to-Speech-Konvertierung großer Mengen.

Mit seinem günstigeren Preis für API-Generierungen und 75 ms Latenz ist Flash v2.5 die kosteneffiziente Option für alle, die schnelle und zuverlässige Sprachsynthese in mehreren Sprachen benötigen.

Flash v2.5 unterstützt 32 Sprachen – alle Sprachen der v2-Modelle sowie:

Ungarisch, Norwegisch & Vietnamesisch

Hinweise

Leitfaden zur Modellauswahl

Hinweise dazu, welches Modell am besten zu Ihren Anforderungen und Ihrem Anwendungsfall passt, finden Sie im Leitfaden zur Modellauswahl.

Zeichenlimits

Die maximale Anzahl unterstützter Zeichen in einer einzelnen Text-to-Speech-Anfrage variiert je nach Modell.

Scribe v2

Scribe v2 ist unser hochmodernes Spracherkennungsmodell für präzise Transkription in über 90 Sprachen. Es bietet genaue Zeitstempel auf Wortebene und erweiterte Funktionen wie Sprecherdiarisierung und dynamische Audio-Tags.

Dieses Modell überzeugt in Szenarien, die eine präzise Speech-to-Text-Konvertierung erfordern:

• Transkriptionsdienste: Perfekt für die Umwandlung von Audio- und Videoinhalten in Text
• Meeting-Dokumentation: Ideal zum Erfassen und Dokumentieren von Gesprächen
• Inhaltsanalyse: Gut geeignet für die Verarbeitung und Analyse von Audioinhalten
• Mehrsprachige Erkennung: Unterstützt präzise Transkription in über 90 Sprachen

Wichtige Funktionen:

• Präzise Transkription mit Zeitstempeln auf Wortebene
• Sprecherdiarisierung für Audio mit mehreren Sprechern
• Dynamische Audio-Tags für zusätzlichen Kontext
• Unterstützung für über 90 Sprachen
• Entitätserkennung
• Keyterm-Prompting
• Transkriptbearbeitung

Lesen Sie hier mehr über Scribe v2.

Scribe v2 Realtime

Scribe v2 Realtime, unser schnellstes und präzisestes Modell für Live-Spracherkennung, liefert hochmoderne Genauigkeit in über 90 Sprachen bei extrem niedrigen 150 ms Latenz.

Dieses Modell überzeugt bei dialogorientierten Anwendungsfällen:

• Live-Meeting-Transkription: Perfekt für Transkription in Echtzeit
• KI-Agenten: Ideal für Live-Gespräche
• Mehrsprachige Erkennung: Unterstützt präzise Transkription in über 90 Sprachen mit automatischer Spracherkennung

Wichtige Funktionen:

• Extrem niedrige Latenz: Erhalten Sie Teiltranskriptionen in ~150 Millisekunden
• Streaming-Unterstützung: Senden Sie Audio in Abschnitten und erhalten Sie Transkripte in Echtzeit
• Mehrere Audioformate: Unterstützung für PCM (8 kHz bis 48 kHz) und μ-law-Kodierung
• Voice Activity Detection (VAD): Automatische Sprachsegmentierung anhand von Stilleerkennung
• Manuelle Commit-Steuerung: Volle Kontrolle darüber, wann Transkriptsegmente abgeschlossen werden
• Entitätserkennung
• Transkriptbearbeitung

Lesen Sie hier mehr über Scribe v2 Realtime.

Scribe v2 Medical

Scribe v2 Medical ist ein Batch-Spracherkennungsmodell, das auf medizinische und klinische Audiodaten spezialisiert ist. Es ist ein Finetune von Scribe v2 und verbessert die Erkennung von Arzneimittelnamen, Anatomie, Pathologie und klinischen Diktaten, während es bei Alltagssprache die Genauigkeit von Scribe v2 erreicht. Es verwendet dieselbe Speech to Text API wie Scribe v2 und wird zum gleichen Preis abgerechnet. Übergeben Sie scribe_v2_medical als model_id.

Dieses Modell eignet sich gut für:

• Klinische Dokumentation: Umgebungsaufnahmen und Notizen, in denen medizinische Begriffe mitten im Gespräch vorkommen
• Diktate: Dichte Abfolgen von Medikamenten, Dosierungen und Befunden
• Aufnahme- und Koordinationstelefonate: Patienten beschreiben ihre eigenen Beschwerden, oft telefonisch
• Compliance-Workflows: Kombinieren Sie es mit Entitätserkennung für PHI-Kategorien

Wichtige Funktionen:

• Dasselbe Anfrageformat wie Scribe v2 (keyterms, entity_detection, no_verbatim, Diarisierung, Zeitstempel)
• Verbesserte Erkennung von Medikamentennamen sowie Begriffen aus Anatomie und Pathologie
• Keine Verschlechterung bei Alltagssprache gegenüber Scribe v2
• Unterstützung für über 90 Sprachen
• Sprecherdiarisierung für Audio mit mehreren Sprechern
• Dynamische Audio-Tags
• Entitätserkennung, einschließlich PHI-Kategorien

Scribe v2 Medical ist ein Batch-Modell. Verwenden Sie für Live-Transkription Scribe v2 Realtime.

Scribe v2 Medical ist HIPAA-fähig. Enterprise-Kunden erhalten Business Associate Agreements sowie den Zero Retention Mode (ZRM). Bei aktiviertem ZRM werden Audioeingabe und Textausgabe sofort nach Abschluss jeder Anfrage gelöscht. ElevenLabs speichert nichts, und Ihre Anwendung erhält die vollständige API-Antwort und verwaltet Transkripte unter Ihren eigenen Kontrollen.

Lesen Sie hier mehr über Speech to Text.

Eleven Realtime

Eleven Realtime ist eine neue Klasse von Speech-to-Speech-Modellen für den Aufbau natürlicher Sprachagenten. Jedes Realtime-Modell ist ein vollständiger Sprachagent: Spracherkennung, Spracherkennung und Sprecherwechsel, LLM sowie Text to Speech, von ElevenLabs ausgewählt und abgestimmt, damit alles als ein System zusammenarbeitet. Wählen Sie ein Realtime-Modell, erhalten Sie mit einer einzigen Auswahl einen leistungsfähigen Agenten – ohne Komponenten konfigurieren zu müssen.

Zwei Realtime-Modelle sind verfügbar.

Eleven Realtime v1 Mini ist für schnelle, natürliche Gespräche optimiert und eignet sich gut für folgende Szenarien:

• KI-Assistenten: Schnelle, ausdrucksstarke Dialoge, bei denen das Gespräch selbst das Produkt ist.
• Lernbegleiter: Natürlicher Austausch, der mit dem Lerntempo Schritt hält.
• Interaktive Charaktere: Ausdrucksstarke Charaktere für Spiele und Unterhaltung.

Eleven Realtime v1 Max ist für komplexe Aufgaben optimiert und eignet sich gut für folgende Szenarien:

• Kundensupport: Lösen von Anfragen, die das Befolgen eines Prozesses und das Abrufen von Informationen erfordern.
• Lead-Qualifizierung: Strukturierte Gespräche, die Informationen erfassen und nächste Schritte festlegen.
• Mehrstufige Workflows: Aufgaben, die Tools aufrufen, um Informationen abzurufen oder Aktionen auszuführen.

Wichtige Funktionen:

• Spracherkennung, Sprecherwechsel, Sprachmodell und Stimme in einer Modellauswahl
• Natürlicher Sprecherwechsel und Umgang mit Unterbrechungen
• Tool-Aufrufe
• Anpassbare Stimmen aus der ElevenLabs-Stimmbibliothek
• Unterstützung für über 90 Sprachen
• Wechsel zwischen v1 Mini und v1 Max durch Modellauswahl statt Integrationsänderung

Eleven Realtime ist in ElevenAgents verfügbar, wo Sie ein Realtime-Modell im Modell-Dropdown auswählen, sowie über die Realtime API, die für Kompatibilität mit OpenAIs Realtime API über WebSocket entwickelt wurde. Wenn Sie bereits OpenAIs Realtime API verwenden, lesen Sie den Migrationsleitfaden.

Unterstützte Sprachen

Realtime-Modelle unterstützen über 90 Sprachen. Siehe die Sprachliste für Eleven v4.

Lesen Sie hier mehr über Eleven Realtime.

Eleven Music

Eleven Music ist unser Musikgenerierungsmodell in Studioqualität. Damit können Sie Musik jedes Stils mit Prompts in natürlicher Sprache erstellen.

Dieses Modell eignet sich hervorragend für folgende Szenarien:

• Spiele-Soundtracks: Erstellen Sie immersive Soundtracks für Spiele
• Podcast-Hintergründe: Ergänzen Sie Podcasts mit professioneller Musik
• Marketing: Fügen Sie Werbe-Reels Hintergrundmusik hinzu

Wichtige Funktionen:

• Vollständige Kontrolle über Genre, Stil und Struktur
• Gesang oder rein instrumental
• Mehrsprachig, einschließlich Englisch, Spanisch, Deutsch, Japanisch und weiteren Sprachen
• Bearbeiten Sie Klang und Liedtext einzelner Abschnitte oder des gesamten Songs

Lesen Sie hier mehr über Eleven Music.

Parallelität und Priorität

Ihr Abonnement bestimmt, wie viele Anfragen gleichzeitig verarbeitet werden können und welche Priorität Ihre Anfragen in der Warteschlange haben. Speech to Text hat ein erhöhtes Parallelitätslimit. Sobald das Parallelitätslimit erreicht ist, werden weitere Anfragen zusammen mit Anfragen niedrigerer Priorität in einer Warteschlange verarbeitet. In der Praxis erhöht dies die Latenz in der Regel nur um etwa 50 ms.

Die Response-Header enthalten current-concurrent-requests und maximum-concurrent-requests, mit denen Sie Ihre Parallelität überwachen können.

API-Anfragen pro Minute im Vergleich zu parallelen Anfragen

Es ist wichtig zu verstehen, dass API-Anfragen pro Minute und parallele Anfragen unterschiedliche Metriken sind, die von Ihren Nutzungsmustern abhängen.

API-Anfragen pro Minute können von parallelen Anfragen abweichen, da dies von der Dauer jeder Anfrage und der Bündelung der Anfragen abhängt.

Beispiel 1: Zeitlich versetzte Anfragen Wenn Sie 180 Anfragen pro Minute hätten, die jeweils 1 Sekunde zur Verarbeitung benötigen, und diese im Abstand von jeweils 0,33 Sekunden senden würden, läge die maximale Anzahl paralleler Anfragen bei 3 und der Durchschnitt ebenfalls bei 3, da immer 3 Anfragen gleichzeitig verarbeitet würden.

Beispiel 2: Gebündelte Anfragen Wenn Sie jedoch ein anderes Nutzungsmuster hätten, etwa 180 Anfragen pro Minute, die jeweils 3 Sekunden zur Verarbeitung benötigen, aber alle gleichzeitig ausgelöst würden, läge die maximale Anzahl paralleler Anfragen bei 180 und der Durchschnitt bei 9 (in den ersten 3 Sekunden der Minute wurden 180 Anfragen gleichzeitig verarbeitet, in den letzten 57 Sekunden 0 Anfragen).

Da unser System die Parallelität berücksichtigt, sind Anfragen pro Minute weniger wichtig als die Dauer jeder Anfrage und das Muster, nach dem sie gesendet werden.

Die Art, wie Endpunktanfragen gestellt werden, beeinflusst die Parallelitätslimits:

• Bei HTTP zählt jede Anfrage einzeln für Ihr Parallelitätslimit.
• Beim Text to Speech WebSocket zählt nur die Zeit, in der unser Modell Audio generiert, für Ihr Parallelitätslimit. Das bedeutet, dass ein offener WebSocket die meiste Zeit gar nicht für Ihr Parallelitätslimit zählt.
• Die Text to Dialogue WebSockets funktionieren anders: Jede offene Verbindung reserviert eine Dialogsitzung aus einem separaten Pool, solange sie geöffnet bleibt. Über die Verbindung generiertes Audio zählt nicht für Ihr Standard-Parallelitätslimit. Das ist leichter nachzuvollziehen, da eine Verbindung einer Sitzung entspricht. Ihre Dialogsitzungslimits sind auf diese neue Methode zur Parallelitätsmessung abgestimmt. Siehe Text to Dialogue-Parallelität.

Parallelitätslimits verstehen

Das Parallelitätslimit Ihres Plans sollte nicht als maximale Anzahl gleichzeitiger Unterhaltungen, Telefonate, Charakter-Voiceovers usw. verstanden werden, die gleichzeitig verarbeitet werden können. Die tatsächliche Anzahl hängt von mehreren Faktoren ab, darunter die verwendeten KI-Stimmen und die Merkmale des Anwendungsfalls.

Als grobe Faustregel kann ein Parallelitätslimit von 5 in der Regel bis zu etwa 100 gleichzeitige Audioübertragungen unterstützen.

Das liegt an der Geschwindigkeit der Audiogenerierung im Verhältnis zur Verarbeitungszeit der TTS-Anfrage. Das folgende Diagramm zeigt beispielhaft, wie 4 parallele Anrufe mit verschiedenen Nutzern ermöglicht werden können, während nur 2 parallele Anfragen anfallen.

Wenn Sie die Parallelitätslimits Ihres Plans überschreiten und den Enterprise-Plan nutzen, können Modellanfragen je nach verfügbarer Kapazität nach bestem Bemühen dennoch erfolgreich sein, jedoch langsamer.

Text to Dialogue-Parallelität

Text to Dialogue-Anfragen werden abhängig davon, wie Sie die API aufrufen, auf zwei verschiedene Arten abgerechnet:

• HTTP-Endpunkte (Dialog erstellen und Dialog streamen) zählen während der Audiogenerierung für das Standard-Parallelitätslimit Ihres Plans, wie jede andere Text to Speech-Anfrage.
• WebSocket-Endpunkte wie der Text to Dialogue WebSocket werden als Dialogsitzungen abgerechnet. Eine offene Verbindung belegt eine Dialogsitzung, solange sie geöffnet bleibt, unabhängig davon, ob gerade Audio generiert wird.

Sitzungsbasierte Abrechnung vereinfacht die Kapazitätsplanung: Eine Verbindung entspricht einer Sitzung, sodass Ihre Nutzung nicht mit der Generierungsaktivität schwankt. Da eine Sitzung für die gesamte Verbindung belegt wird und nicht nur während der Audiogenerierung, sind Ihre Dialogsitzungslimits auf diese neue Methode zur Parallelitätsmessung abgestimmt.

Wenn Sie eine Verbindung öffnen, während alle Dialogsitzungen Ihres Workspaces belegt sind, wird die neue Verbindung mit einem too_many_concurrent_requests-Fehler abgelehnt. Um Sitzungen freizugeben, schließen Sie nicht mehr benötigte Verbindungen. Eine Verbindung wird außerdem nach 20 Sekunden Inaktivität automatisch geschlossen, sofern Sie keine keep_alive-Nachrichten senden.

Um Dialogsitzungen zu überwachen, öffnen Sie unten in der Dashboard-Seitenleiste Developers, wählen Sie den Tab Analytics und sehen Sie sich in der Nutzungsansicht die Metrik Concurrent requests an. Dialogsitzungen werden als eigene Reihe, TTD Websocket Sessions, getrennt von Ihren anderen parallelen Anfragen angezeigt.

Parallelitätslimits mit Skalierungstests prüfen

Skalierungstests können helfen, clientseitige Skalierungsprobleme zu erkennen und zu überprüfen, ob Parallelitätslimits für Ihren Anwendungsfall korrekt festgelegt sind.

Es wird dringend empfohlen, End-to-End-Workflows so nah wie möglich an der realen Nutzung zu testen. Die empfohlene Methode dafür ist, zu simulieren und zu messen, wie viele Nutzer unterstützt werden können. Wichtig ist:

• Simulieren Sie Nutzer, nicht reine Anfragen.
• Simulieren Sie typisches Nutzerverhalten, etwa das Warten auf Audiowiedergabe, das Sprechen des Nutzers oder den Abschluss der Transkription, bevor Anfragen gestellt werden.
• Erhöhen Sie die Nutzerzahl über mehrere Minuten hinweg langsam.
• Variieren Sie Anforderungszeitpunkte und Größe der Anfragen zufällig.
• Erfassen Sie Latenzmetriken und alle von der API zurückgegebenen Fehlercodes.

Um beispielsweise ein Agentensystem zu testen, das für 100 gleichzeitige Gespräche ausgelegt ist, würden Sie bis zu 100 einzelne „Nutzer“ erstellen, die jeweils ein Gespräch simulieren. Gespräche bestehen typischerweise aus einem wiederholten Zyklus von etwa 10 Sekunden Nutzersprache, gefolgt von einem TTS-API-Aufruf für etwa 150 Zeichen und anschließend etwa 10 Sekunden Audiowiedergabe für den Nutzer. Daher sollte jeder Nutzer dem Muster folgen, alle 20 Sekunden einen WebSocket-Text-to-Speech-API-Aufruf für 150 Textzeichen auszuführen, wobei die Wartezeit und die Anzahl angeforderter Zeichen leicht zufällig variiert werden. Der Test würde darin bestehen, jede Sekunde einen Nutzer zu starten, bis 100 vorhanden sind, und dann insgesamt 10 Minuten lang die Gesamtstabilität zu testen.

import json
import random
import time
import gevent
import locust
from locust import User, task, events, constant_throughput
import websocket
# Averages up to 10 seconds of audio when played, depends on the voice speed
DEFAULT_TEXT = (
    "Hello, this is a test message. I am testing if a long input will cause issues for the model "
    "like this sentence. "
)
TEXT_ARRAY = [
    "Hello.",
    "Hello, this is a test message.",
    DEFAULT_TEXT,
    DEFAULT_TEXT * 2,
    DEFAULT_TEXT * 3
]
# Custom command line arguments
@events.init_command_line_parser.add_listener
def on_parser_init(parser):
    parser.add_argument("--api-key", default="YOUR_API_KEY", help="API key for authentication")
    parser.add_argument("--encoding", default="mp3_22050_32", help="Encoding")
    parser.add_argument("--text", default=DEFAULT_TEXT, help="Text to use")
    parser.add_argument("--use-text-array", default="false", help="Text to use")
    parser.add_argument("--voice-id", default="aria", help="Text to use")
class WebSocketTTSUser(User):
    # Each user will send a request every 20 seconds, regardless of how long each request takes
    wait_time = constant_throughput(0.05)
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.api_key = self.environment.parsed_options.api_key
        self.voice_id = self.environment.parsed_options.voice_id
        self.text = self.environment.parsed_options.text
        self.encoding = self.environment.parsed_options.encoding
        self.use_text_array = self.environment.parsed_options.use_text_array
        if self.use_text_array:
            self.text = random.choice(TEXT_ARRAY)
        self.all_recieved = False
    @task
    def tts_task(self):
        # Do jitter waiting of up to 1 second
        # Users appear to be spawned every second so this ensures requests are not aligned
        gevent.sleep(random.random())
        max_wait_time = 10
        # Connection details
        uri = f"{self.environment.host}/v1/text-to-speech/{self.voice_id}/stream-input?auto_mode=true&output_format={self.encoding}"
        headers = {"xi-api-key": self.api_key}
        ws = None
        self.all_recieved = False
        try:
            init_msg = {"text": " "}
            # Use proper header format for websocket - this is case sensitive!
            ws = websocket.create_connection(uri, header=headers)
            ws.send(json.dumps(init_msg))
            # Start measuring after websocket initiated but before any messages are sent
            send_request_time = time.perf_counter()
            ws.send(json.dumps({"text": self.text}))
            # Send to flush and receive the audio
            ws.send(json.dumps({"text": ""}))
            def _receive():
                t_first_response = None
                audio_size = 0
                try:
                    while True:
                        # Wait up to 10 seconds for a response
                        ws.settimeout(max_wait_time)
                        response = ws.recv()
                        response_data = json.loads(response)
                        if "audio" in response_data and response_data["audio"]:
                            audio_size = audio_size + len(response_data["audio"])
                        if t_first_response is None:
                            t_first_response = time.perf_counter()
                            first_byte_ms = (
                                t_first_response - send_request_time
                            ) * 1000
                            if audio_size is None:
                                # The first response should always have audio
                                locust.events.request.fire(
                                    request_type="websocket",
                                    name="Bad Response (no audio)",
                                    response_time=first_byte_ms,
                                    response_length=audio_size,
                                    exception=Exception("Response has no audio"),
                                )
                                break
                        if "isFinal" in response_data and response_data["isFinal"]:
                            # Fire this event once finished streaming, but report the important TTFB metric
                            locust.events.request.fire(
                                request_type="websocket",
                                name="TTS Stream Success (First Byte)",
                                response_time=first_byte_ms,
                                response_length=audio_size,
                                exception=None,
                            )
                            break
                except websocket.WebSocketTimeoutException:
                    locust.events.request.fire(
                        request_type="websocket",
                        name="TTS Stream Timeout",
                        response_time=max_wait_time * 1000,
                        response_length=audio_size,
                        exception=Exception("Timeout waiting for response"),
                    )
                except Exception as e:
                    # Typically JSON decode error if the server returns HTTP backoff error
                    locust.events.request.fire(
                        request_type="websocket",
                        name="TTS Stream Failure",
                        response_time=0,
                        response_length=0,
                        exception=e,
                    )
                finally:
                    self.all_recieved = True
            gevent.spawn(_receive)
            # Sleep until recieved so new tasks aren't spawned
            while not self.all_recieved:
                gevent.sleep(1)
        except websocket.WebSocketTimeoutException:
            locust.events.request.fire(
                request_type="websocket",
                name="TTS Stream Timeout",
                response_time=max_wait_time * 1000,
                response_length=0,
                exception=Exception("Timeout waiting for response"),
            )
        except Exception as e:
            locust.events.request.fire(
                request_type="websocket",
                name="TTS Stream Failure",
                response_time=0,
                response_length=0,
                exception=e,
            )
        finally:
            # Try and close the websocket gracefully
            try:
                if ws:
                    ws.close()
            except Exception:
                pass