Modeller

Flaggskeppsmodeller

Text to Speech

Speech to Text

Röstbaserade agenter

Musik

Modellöversikt

ElevenLabs API erbjuder en rad ljudmodeller som är optimerade för olika användningsområden, kvalitetsnivåer och prestandakrav.

Utfasade modeller

Eleven v4

Eleven v4 är vår toppmoderna talsyntesmodell och levererar ljud av vår högsta kvalitet, uttrycksfullhet och kontroll över hur röster framförs. Eleven v4 har stöd för röstkloning med hög återgivningstrohet och bevarar talarens röst på ett tillförlitligt sätt i långa textgenereringar.

Modellen fungerar bra i följande scenarier:

• Karaktärsröster: Perfekt för spel och animation tack vare sitt känslomässiga omfång.
• Känslomässiga dialoger: Generera naturliga, verklighetstrogna dialoger med stort känslomässigt omfång och kontextförståelse.
• Ljudboksproduktion: Perfekt för långa berättelser med komplex känslomässig leverans.
• Flerspråkiga projekt: Bibehåller jämn röstkvalitet vid språkbyten.

Eleven v4 är tillgänglig via Text to Dialogue API.

Språk som stöds

Modellfamiljen Eleven v4 stöder över 90 språk, bland annat:

Afrikaans (af), arabiska (ar), armeniska (hy), assamesiska (as), asturiska (ast), azerbajdzjanska (az), belarusiska (be), bengaliska (bn), bosniska (bs), bulgariska (bg), burmesiska (my), kantonesiska (yue), katalanska (ca), cebuano (ceb), kroatiska (hr), tjeckiska (cs), danska (da), nederländska (nl), engelska (en), estniska (et), filippinska (fil), finska (fi), franska (fr), galiciska (gl), georgiska (ka), tyska (de), grekiska (el), gujarati (gu), hausa (ha), hebreiska (he), hindi (hi), ungerska (hu), isländska (is), indonesiska (id), iriska (ga), italienska (it), japanska (ja), javanesiska (jv), kannada (kn), kazakiska (kk), koreanska (ko), kirgiziska (ky), lettiska (lv), lingala (ln), litauiska (lt), luxemburgiska (lb), makedonska (mk), malajiska (ms), malayalam (ml), maltesiska (mt), mandarin (zh), maori (mi), marathi (mr), mongoliska (mn), nepalesiska (ne), norska (no), occitanska (oc), odia (or), pashto (ps), persiska (fa), polska (pl), portugisiska (pt), punjabi (pa), rumänska (ro), ryska (ru), serbiska (sr), sindhi (sd), slovakiska (sk), slovenska (sl), somaliska (so), spanska (es), swahili (sw), svenska (sv), tadzjikiska (tg), tamil (ta), telugu (te), thailändska (th), turkiska (tr), ukrainska (uk), urdu (ur), uzbekiska (uz), vietnamesiska (vi), walesiska (cy), yoruba (yo).

Eleven v4 Turbo

Eleven v4 Turbo är vår toppmoderna modell för talsyntes i realtid och levererar ljud av hög kvalitet, uttrycksfullhet och kontroll över hur röster framförs. Eleven v4 Turbo har stöd för röstkloning med hög återgivningstrohet och levererar resultat med en medianlatens för inferens på ~100 ms.

Modellen fungerar bra i följande scenarier:

• Supportagenter: Driv röstagenter som löser kundfrågor i realtid.
• AI-assistenter: Generera naturliga, verklighetstrogna dialoger med stort känslomässigt omfång och kontextförståelse.
• Interaktiva karaktärer: Utmärkt för ljudupplevelser med uttrycksfulla karaktärer.

Eleven v4 Turbo är tillgänglig via Text to Dialogue-websocket.

Språk som stöds

Modellfamiljen Eleven v4 stöder över 90 språk, bland annat:

Afrikaans (af), arabiska (ar), armeniska (hy), assamesiska (as), asturiska (ast), azerbajdzjanska (az), belarusiska (be), bengaliska (bn), bosniska (bs), bulgariska (bg), burmesiska (my), kantonesiska (yue), katalanska (ca), cebuano (ceb), kroatiska (hr), tjeckiska (cs), danska (da), nederländska (nl), engelska (en), estniska (et), filippinska (fil), finska (fi), franska (fr), galiciska (gl), georgiska (ka), tyska (de), grekiska (el), gujarati (gu), hausa (ha), hebreiska (he), hindi (hi), ungerska (hu), isländska (is), indonesiska (id), iriska (ga), italienska (it), japanska (ja), javanesiska (jv), kannada (kn), kazakiska (kk), koreanska (ko), kirgiziska (ky), lettiska (lv), lingala (ln), litauiska (lt), luxemburgiska (lb), makedonska (mk), malajiska (ms), malayalam (ml), maltesiska (mt), mandarin (zh), maori (mi), marathi (mr), mongoliska (mn), nepalesiska (ne), norska (no), occitanska (oc), odia (or), pashto (ps), persiska (fa), polska (pl), portugisiska (pt), punjabi (pa), rumänska (ro), ryska (ru), serbiska (sr), sindhi (sd), slovakiska (sk), slovenska (sl), somaliska (so), spanska (es), swahili (sw), svenska (sv), tadzjikiska (tg), tamil (ta), telugu (te), thailändska (th), turkiska (tr), ukrainska (uk), urdu (ur), uzbekiska (uz), vietnamesiska (vi), walesiska (cy), yoruba (yo).

Eleven v3

Eleven v3 är vår föregående generations talsyntesmodell som producerar naturligt, verklighetstroget tal med stort känslomässigt omfång och kontextförståelse på flera språk.

Med Eleven v3 får du ett nytt Text to Dialogue API, som låter dig generera naturliga, verklighetstrogna dialoger med stort känslomässigt omfång och kontextförståelse på flera språk. Eleven v3 kan även användas med Text to Speech API för att generera naturligt, verklighetstroget tal med stort känslomässigt omfång och kontextförståelse på flera språk.

Läs mer om Text to Dialogue API här.

Språk som stöds

Modellen Eleven v3 stöder över 70 språk, bland annat:

Afrikaans (af), arabiska (ar), armeniska (hy), assamesiska (as), asturiska (ast), azerbajdzjanska (az), belarusiska (be), bengaliska (bn), bosniska (bs), bulgariska (bg), burmesiska (my), kantonesiska (yue), katalanska (ca), cebuano (ceb), chichewa (ny), kroatiska (hr), tjeckiska (cs), danska (da), nederländska (nl), engelska (en), estniska (et), filippinska (fil), finska (fi), franska (fr), galiciska (gl), georgiska (ka), tyska (de), grekiska (el), gujarati (gu), hausa (ha), hebreiska (he), hindi (hi), ungerska (hu), isländska (is), indonesiska (id), iriska (ga), italienska (it), japanska (ja), javanesiska (jv), kannada (kn), kazakiska (kk), kirgiziska (ky), koreanska (ko), lettiska (lv), lingala (ln), litauiska (lt), luxemburgiska (lb), makedonska (mk), malajiska (ms), malayalam (ml), maltesiska (mt), mandarin (zh), maori (mi), marathi (mr), mongoliska (mn), nepalesiska (ne), norska (no), occitanska (oc), odia (or), pashto (ps), persiska (fa), polska (pl), portugisiska (pt), punjabi (pa), rumänska (ro), ryska (ru), serbiska (sr), sindhi (sd), slovakiska (sk), slovenska (sl), somaliska (so), spanska (es), swahili (sw), svenska (sv), tadzjikiska (tg), tamil (ta), telugu (te), thailändska (th), turkiska (tr), ukrainska (uk), urdu (ur), uzbekiska (uz), vietnamesiska (vi), walesiska (cy), yoruba (yo).

Eleven v3 Conversational

Eleven v3 Conversational är vår föregående generations modell för talsyntes i realtid. Den producerar naturligt, verklighetstroget tal med stort känslomässigt omfång och kontextförståelse på flera språk.

Med Eleven v3 Conversational får du en ny Text to Dialogue WebSocket, som låter dig generera naturliga, verklighetstrogna dialoger med stort känslomässigt omfång och kontextförståelse på flera språk.

Med Eleven v3 Conversational får du en ny Text to Dialogue WebSocket, som låter dig generera naturliga, verklighetstrogna dialoger med stort känslomässigt omfång och kontextförståelse på flera språk.

Läs mer om Text to Dialogue WebSocket här.

Språk som stöds

Modellen Eleven v3 stöder över 70 språk, bland annat:

Afrikaans (af), arabiska (ar), armeniska (hy), assamesiska (as), asturiska (ast), azerbajdzjanska (az), belarusiska (be), bengaliska (bn), bosniska (bs), bulgariska (bg), burmesiska (my), kantonesiska (yue), katalanska (ca), cebuano (ceb), chichewa (ny), kroatiska (hr), tjeckiska (cs), danska (da), nederländska (nl), engelska (en), estniska (et), filippinska (fil), finska (fi), franska (fr), galiciska (gl), georgiska (ka), tyska (de), grekiska (el), gujarati (gu), hausa (ha), hebreiska (he), hindi (hi), ungerska (hu), isländska (is), indonesiska (id), iriska (ga), italienska (it), japanska (ja), javanesiska (jv), kannada (kn), kazakiska (kk), kirgiziska (ky), koreanska (ko), lettiska (lv), lingala (ln), litauiska (lt), luxemburgiska (lb), makedonska (mk), malajiska (ms), malayalam (ml), maltesiska (mt), mandarin (zh), maori (mi), marathi (mr), mongoliska (mn), nepalesiska (ne), norska (no), occitanska (oc), odia (or), pashto (ps), persiska (fa), polska (pl), portugisiska (pt), punjabi (pa), rumänska (ro), ryska (ru), serbiska (sr), sindhi (sd), slovakiska (sk), slovenska (sl), somaliska (so), spanska (es), swahili (sw), svenska (sv), tadzjikiska (tg), tamil (ta), telugu (te), thailändska (th), turkiska (tr), ukrainska (uk), urdu (ur), uzbekiska (uz), vietnamesiska (vi), walesiska (cy), yoruba (yo).

Multilingual v2

Eleven Multilingual v2 är en känslomedveten talsyntesmodell från en tidigare generation. Den producerar naturligt, verklighetstroget tal med stort känslomässigt omfång och kontextförståelse på flera språk.

Modellen ger jämn röstkvalitet och personlighet på alla språk som stöds, samtidigt som talarens unika egenskaper och accent behålls.

Den här modellen utmärker sig i scenarier som kräver högkvalitativt och känslomässigt nyanserat tal:

• Karaktärsröster: Perfekt för spel och animation tack vare sitt känslomässiga omfång.
• Professionellt innehåll: Väl lämpad för företagsvideor och e-utbildningsmaterial.
• Flerspråkiga projekt: Bibehåller jämn röstkvalitet vid språkbyten.
• Stabil kvalitet: Producerar jämn ljudutdata av hög kvalitet.

Även om den har högre latens och kostnad per tecken än Flash-modeller, ger den överlägsen kvalitet för projekt där verklighetstroget tal är viktigt.

Våra flerspråkiga v2-modeller har stöd för 29 språk:

Engelska (USA, Storbritannien, Australien, Kanada), japanska, kinesiska, tyska, hindi, franska (Frankrike, Kanada), koreanska, portugisiska (Brasilien, Portugal), italienska, spanska (Spanien, Mexiko), indonesiska, nederländska, turkiska, filippinska, polska, svenska, bulgariska, rumänska, arabiska (Saudiarabien, Förenade Arabemiraten), tjeckiska, grekiska, finska, kroatiska, malajiska, slovakiska, danska, tamil, ukrainska och ryska.

Flash v2.5

Eleven Flash v2.5 är vår snabbaste talsyntesmodell, utformad för realtidsapplikationer och Agents Platform. Den levererar högkvalitativt tal med ultralåg latens (~75 ms†) på 32 språk.

Modellen balanserar hastighet och kvalitet, vilket gör den perfekt för interaktiva applikationer samtidigt som den bibehåller naturligt ljudande utdata och jämna röstegenskaper mellan språk.

Den här modellen passar särskilt bra för:

• Agents Platform: Perfekt för röstagenter och chattbotar i realtid.
• Interaktiva applikationer: Perfekt för spel och applikationer som kräver omedelbar respons.
• Storskalig bearbetning: Effektiv för storskalig text-till-tal-konvertering.

Med sitt lägre pris för API-genereringar och 75 ms latens är Flash v2.5 det kostnadseffektiva alternativet för alla som behöver snabb, tillförlitlig talsyntes på flera språk.

Flash v2.5 har stöd för 32 språk – alla språk från v2-modellerna samt:

Ungerska, norska och vietnamesiska

Att tänka på

Guide för modellval

För vägledning om vilken modell som passar dina behov och ditt användningsfall bäst, se guiden för modellval.

Teckenbegränsningar

Det maximala antalet tecken som stöds i en enskild text-till-tal-förfrågan varierar beroende på modell.

Scribe v2

Scribe v2 är vår toppmoderna taligenkänningsmodell, utformad för korrekt transkribering på över 90 språk. Den ger exakta tidsstämplar på ordnivå och avancerade funktioner som talardiarisering och dynamisk ljudtaggning.

Den här modellen utmärker sig i scenarier som kräver korrekt tal-till-text-konvertering:

• Transkriberingstjänster: Perfekt för att konvertera ljud- och videoinnehåll till text
• Mötesdokumentation: Perfekt för att fånga och dokumentera samtal
• Innehållsanalys: Väl lämpad för bearbetning och analys av ljudinnehåll
• Flerspråkig igenkänning: Stöder korrekt transkribering på över 90 språk

Viktiga funktioner:

• Korrekt transkribering med tidsstämplar på ordnivå
• Talardiarisering för ljud med flera talare
• Dynamisk ljudtaggning för mer kontext
• Stöd för över 90 språk
• Entitetsidentifiering
• Nyckeltermsinmatning
• Redigering av transkript

Läs mer om Scribe v2 här.

Scribe v2 Realtime

Scribe v2 Realtime, vår snabbaste och mest exakta modell för live-taligenkänning, ger toppmodern precision på över 90 språk med en ultralåg latens på 150 ms.

Den här modellen utmärker sig i konversationsbaserade användningsfall:

• Live-transkribering av möten: Perfekt för transkribering i realtid
• AI-agenter: Perfekt för livesamtal
• Flerspråkig igenkänning: Stöder korrekt transkribering på över 90 språk med automatisk språkigenkänning

Viktiga funktioner:

• Ultralåg latens: Få partiella transkriberingar på ~150 millisekunder
• Stöd för streaming: Skicka ljud i delar medan du tar emot transkript i realtid
• Flera ljudformat: Stöd för PCM (8 kHz till 48 kHz) och μ-law-kodning
• Voice Activity Detection (VAD): Automatisk segmentering av tal baserat på tystnadsidentifiering
• Manuell commit-kontroll: Full kontroll över när transkriptsegment ska slutföras
• Entitetsidentifiering
• Redigering av transkript

Läs mer om Scribe v2 Realtime här.

Scribe v2 Medical

Scribe v2 Medical är en batchmodell för taligenkänning som är specialiserad på medicinskt och kliniskt ljud. Den är en finjusterad version av Scribe v2 som förbättrar igenkänningen av läkemedelsnamn, anatomi, patologi och klinisk diktering, samtidigt som den matchar Scribe v2:s precision för vardagligt tal. Den använder samma Speech to Text API som Scribe v2 och debiteras till samma pris. Skicka scribe_v2_medical som model_id.

Den här modellen passar bra för:

• Klinisk dokumentation: Omgivande samtal och anteckningar där medicinska termer förekommer mitt i samtalet
• Diktering: Täta sekvenser av läkemedel, doseringar och fynd
• Inringnings- och samordningssamtal: Patienter som beskriver sina egna tillstånd, ofta via telefon
• Efterlevnadsarbetsflöden: Kombinera med entitetsidentifiering för PHI-kategorier

Viktiga funktioner:

• Samma förfrågningsformat som Scribe v2 (keyterms, entity_detection, no_verbatim, diarization, timestamps)
• Förbättrad igenkänning av läkemedelsnamn samt anatomiska och patologiska termer
• Ingen försämring för vardagligt tal jämfört med Scribe v2
• Stöd för över 90 språk
• Talardiarisering för ljud med flera talare
• Dynamisk ljudtaggning
• Entitetsidentifiering, inklusive PHI-kategorier

Scribe v2 Medical är en batchmodell. Använd Scribe v2 Realtime för live-transkribering.

Scribe v2 Medical omfattas av HIPAA, med Business Associate Agreements tillgängliga för Enterprise-kunder samt Zero Retention Mode (ZRM). När ZRM är aktiverat raderas ljudindata och textutdata direkt efter att varje förfrågan har slutförts. ElevenLabs sparar ingenting, och din applikation får hela API-svaret och behåller transkript under dina egna kontroller.

Läs mer om Speech to Text här.

Eleven Realtime

Eleven Realtime är en ny typ av Speech to Speech-modeller för att bygga naturliga röstagenter. Varje Realtime-modell är en komplett röstagent: taligenkänning, röstaktivitetsidentifiering och turtagning, LLM och text till tal, utvalda och finjusterade av ElevenLabs för att fungera tillsammans som ett system. Välj en Realtime-modell så får du en välpresterande agent genom ett enda val, utan komponenter att konfigurera.

Två Realtime-modeller är tillgängliga.

Eleven Realtime v1 Mini är optimerad för snabba, naturliga samtal och fungerar bra i följande scenarier:

• AI-assistenter: Snabb, uttrycksfull dialog där själva samtalet är produkten.
• Utbildningshandledare: Naturliga samtal fram och tillbaka som följer elevens tempo.
• Interaktiva karaktärer: Uttrycksfulla karaktärer för spel och underhållning.

Eleven Realtime v1 Max är optimerad för komplexa uppgifter och fungerar bra i följande scenarier:

• Kundsupport: Löser frågor som kräver att följa en process och slå upp information.
• Kvalificering av leads: Strukturerade samtal som samlar in information och avgör nästa steg.
• Arbetsflöden i flera steg: Uppgifter som anropar verktyg för att slå upp information eller utföra åtgärder.

Viktiga funktioner:

• Taligenkänning, turtagning, språkmodell och röst i ett modellval
• Naturlig turtagning och hantering av avbrott
• Verktygsanrop
• Anpassningsbara röster från ElevenLabs röstbibliotek
• Stöd för över 90 språk
• Växla mellan v1 Mini och v1 Max genom ett modellval, utan att ändra integrationen

Eleven Realtime är tillgänglig i ElevenAgents, där du väljer en Realtime-modell i modellmenyn, och via Realtime API, som är utformat för att vara kompatibelt med OpenAI:s Realtime API över WebSocket. Om du redan använder OpenAI:s Realtime API, se migreringsguiden.

Språk som stöds

Realtime-modeller har stöd för över 90 språk. Se språklistan för Eleven v4.

Läs mer om Eleven Realtime här.

Eleven Music

Eleven Music är vår musikgenereringsmodell i studiokvalitet. Den låter dig generera musik i valfri stil med prompter på naturligt språk.

Den här modellen passar utmärkt för följande scenarier:

• Musik för spel: Skapa uppslukande musik för spel
• Bakgrundsmusik för poddar: Förbättra poddar med professionell musik
• Marknadsföring: Lägg till bakgrundsmusik i annonsvideor

Viktiga funktioner:

• Fullständig kontroll över genre, stil och struktur
• Sång eller endast instrumentalt
• Flerspråkig, inklusive engelska, spanska, tyska, japanska med mera
• Redigera ljudet och texten i enskilda avsnitt eller hela låten

Läs mer om Eleven Music här.

Samtidighet och prioritet

Din prenumerationsplan avgör hur många begäranden som kan behandlas samtidigt och vilken prioritetsnivå dina begäranden har i kön. Speech to Text har en högre samtidighetsgräns. När samtidighetsgränsen har nåtts behandlas efterföljande begäranden i en kö tillsammans med begäranden med lägre prioritet. I praktiken tillkommer vanligtvis bara cirka 50 ms latens.

Svarshuvudena innehåller current-concurrent-requests och maximum-concurrent-requests, som du kan använda för att övervaka din samtidighet.

API-begäranden per minut jämfört med samtidiga begäranden

Det är viktigt att förstå att API-begäranden per minut och samtidiga begäranden är olika mått som beror på dina användningsmönster.

API-begäranden per minut kan skilja sig från samtidiga begäranden eftersom det beror på hur lång tid varje begäran tar och hur begärandena grupperas.

Exempel 1: Utspridda begäranden Om du hade 180 begäranden per minut som var och en tog 1 sekund att slutföra och du skickade dem med 0,33 sekunders mellanrum, skulle det maximala antalet samtidiga begäranden vara 3 och genomsnittet skulle vara 3, eftersom det alltid skulle finnas 3 pågående begäranden.

Exempel 2: Gruppvisa begäranden Om du däremot hade ett annat användningsmönster, till exempel 180 begäranden per minut som var och en tog 3 sekunder att slutföra men alla skickades samtidigt, skulle det maximala antalet samtidiga begäranden vara 180 och genomsnittet skulle vara 9 (under minutens första 3 sekunder skickades 180 begäranden samtidigt, under de sista 57 sekunderna skickades 0 begäranden).

Eftersom vårt system fokuserar på samtidighet är antalet begäranden per minut mindre viktigt än hur lång tid varje begäran tar och mönstret för när de skickas.

Hur endpoint-begäranden görs påverkar samtidighetsgränserna:

• Med HTTP räknas varje begäran individuellt mot din samtidighetsgräns.
• Med Text to Speech WebSocket räknas endast tiden då vår modell genererar ljud mot din samtidighetsgräns. Det innebär att en öppen websocket oftast inte alls räknas mot din samtidighetsgräns.
• Text to Dialogue WebSockets fungerar annorlunda: varje öppen anslutning reserverar en dialogsession från en separat pool så länge den är öppen, och ljud som genereras via anslutningen räknas inte mot din vanliga samtidighetsgräns. Det är utformat för att vara enklare att förstå, eftersom en anslutning motsvarar en session, och dina gränser för dialogsessioner är dimensionerade för denna nya metod för samtidighet. Se Text to Dialogue-samtidighet.

Förstå samtidighetsgränser

Samtidighetsgränsen för din plan ska inte tolkas som det maximala antalet samtidiga konversationer, telefonsamtal, karaktärsvoice-overs osv. som kan hanteras samtidigt. Det faktiska antalet beror på flera faktorer, inklusive vilka specifika AI-röster som används och användningsområdets egenskaper.

Som en generell tumregel kan en samtidighetsgräns på 5 vanligtvis hantera upp till cirka 100 samtidiga ljudsändningar.

Det beror på hastigheten med vilken ljud genereras i förhållande till den tid det tar att behandla TTS-begäran. Diagrammet nedan visar ett exempel på hur 4 samtidiga samtal med olika användare kan hanteras samtidigt som endast 2 samtidiga begäranden används.

Om du någon gång överskrider din plans samtidighetsgränser och använder Enterprise-planen kan modellbegäranden ändå lyckas, men långsammare, i mån av tillgänglig kapacitet.

Text to Dialogue-samtidighet

Text to Dialogue-begäranden mäts på två olika sätt beroende på hur du anropar API:et:

• HTTP-endpoints (Skapa dialog och Strömma dialog) räknas mot din plans vanliga samtidighetsgräns medan ljud genereras, precis som andra Text to Speech-begäranden.
• WebSocket-endpoints som Text to Dialogue WebSocket mäts som dialogsessioner. En öppen anslutning håller en dialogsession så länge den är öppen, oavsett om ljud genereras just nu eller inte.

Sessionsbaserad mätning gör kapacitetsplaneringen enkel: en anslutning är en session, så din användning varierar inte med genereringsaktiviteten. Eftersom en session hålls under hela anslutningen i stället för bara medan ljud genereras, är dina gränser för dialogsessioner dimensionerade för denna nya metod för samtidighet.

Om du öppnar en anslutning medan alla arbetsytans dialogsessioner används avvisas den nya anslutningen med felet too_many_concurrent_requests. Frigör sessioner genom att stänga anslutningar du inte längre behöver — en anslutning stängs också automatiskt efter 20 sekunders inaktivitet, om du inte skickar keep_alive-meddelanden.

För att övervaka dialogsessioner öppnar du Developers längst ned i instrumentpanelens sidofält, väljer fliken Analytics och visar mätvärdet Concurrent requests i vyn Usage. Dialogsessioner rapporteras som en egen serie, TTD Websocket Sessions, separat från dina andra samtidiga begäranden.

Samtidighetsgränser vid skaltestning

Skaltestning kan vara användbart för att identifiera skalningsproblem på klientsidan och verifiera att samtidighetsgränserna är rätt inställda för ditt användningsfall.

Vi rekommenderar starkt att testa kompletta arbetsflöden så nära verklig användning som möjligt. Den rekommenderade metoden är att simulera och mäta hur många användare som kan hanteras. Det är viktigt att:

• Simulera användare, inte enbart begäranden
• Simulera typiskt användarbeteende, som att vänta tills ljuduppspelning, användarens tal eller transkribering är klar innan begäranden görs
• Öka antalet användare långsamt under några minuter
• Lägga till slumpmässighet i tidpunkterna för begäranden och i begärandenas storlek
• Samla in latensmått och eventuella felkoder som returneras från API:et

För att exempelvis testa ett agentsystem som är utformat för att stödja 100 samtidiga konversationer skapar du upp till 100 enskilda “användare” som var och en simulerar en konversation. Konversationer består vanligtvis av en upprepad cykel med cirka 10 sekunders tal från användaren, följt av ett TTS API-anrop för cirka 150 tecken, följt av cirka 10 sekunders ljuduppspelning för användaren. Därför bör varje användare följa mönstret att göra ett Text-to-Speech API-anrop via websocket för 150 tecken text var 20:e sekund, med en liten mängd slumpmässighet i väntetiden och antalet begärda tecken. Testet skulle bestå av att starta en användare per sekund tills 100 finns och sedan testa i totalt 10 minuter för att testa den övergripande stabiliteten.

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