Modelli

Modelli di punta

Text to Speech

Speech to Text

Agenti vocali

Musica

Panoramica dei modelli

L’API ElevenLabs offre una gamma di modelli audio ottimizzati per diversi casi d’uso, livelli di qualità e requisiti di prestazioni.

Modelli deprecati

Eleven v4

Eleven v4 è il nostro modello all’avanguardia per la sintesi vocale e offre audio della massima qualità, espressività e controllo sull’interpretazione delle voci. Eleven v4 supporta la clonazione vocale ad alta fedeltà, con una preservazione affidabile del parlante nelle generazioni di testi lunghi.

Questo modello funziona bene nei seguenti scenari:

• Voci fuori campo per personaggi: Ideale per giochi e animazione grazie alla sua ampia gamma emotiva.
• Dialoghi emotivi: Genera dialoghi naturali e realistici, con un’ampia gamma emotiva e comprensione del contesto.
• Produzione di audiolibri: Perfetto per narrazioni lunghe con interpretazioni emotive complesse.
• Progetti multilingue: Mantiene una qualità vocale coerente nei passaggi tra le lingue.

Eleven v4 è disponibile tramite la Text to Dialogue API.

Lingue supportate

La famiglia di modelli Eleven v4 supporta oltre 90 lingue, tra cui:

Afrikaans (af), arabo (ar), armeno (hy), assamese (as), asturiano (ast), azero (az), bielorusso (be), bengalese (bn), bosniaco (bs), bulgaro (bg), birmano (my), cantonese (yue), catalano (ca), cebuano (ceb), croato (hr), ceco (cs), danese (da), olandese (nl), inglese (en), estone (et), filippino (fil), finlandese (fi), francese (fr), galiziano (gl), georgiano (ka), tedesco (de), greco (el), gujarati (gu), hausa (ha), ebraico (he), hindi (hi), ungherese (hu), islandese (is), indonesiano (id), irlandese (ga), italiano (it), giapponese (ja), giavanese (jv), kannada (kn), kazako (kk), coreano (ko), kirghiso (ky), lettone (lv), lingala (ln), lituano (lt), lussemburghese (lb), macedone (mk), malese (ms), malayalam (ml), maltese (mt), cinese mandarino (zh), māori (mi), marathi (mr), mongolo (mn), nepalese (ne), norvegese (no), occitano (oc), odia (or), pashtu (ps), persiano (fa), polacco (pl), portoghese (pt), punjabi (pa), rumeno (ro), russo (ru), serbo (sr), sindhi (sd), slovacco (sk), sloveno (sl), somalo (so), spagnolo (es), swahili (sw), svedese (sv), tagico (tg), tamil (ta), telugu (te), thai (th), turco (tr), ucraino (uk), urdu (ur), uzbeko (uz), vietnamita (vi), gallese (cy), yoruba (yo).

Eleven v4 Turbo

Eleven v4 Turbo è il nostro modello all’avanguardia per la sintesi vocale in tempo reale e offre audio di alta qualità, espressività e controllo sull’interpretazione delle voci. Eleven v4 Turbo supporta la clonazione vocale ad alta fedeltà e fornisce risultati con una latenza mediana di inferenza di circa 100 ms.

Questo modello funziona bene nei seguenti scenari:

• Agenti di assistenza: Alimenta agenti vocali che risolvono le richieste dei clienti in tempo reale.
• Assistenti IA: Genera dialoghi naturali e realistici, con un’ampia gamma emotiva e comprensione del contesto.
• Personaggi interattivi: Eccellente per esperienze audio con personaggi espressivi.

Eleven v4 Turbo è disponibile tramite il websocket Text to Dialogue.

Lingue supportate

La famiglia di modelli Eleven v4 supporta oltre 90 lingue, tra cui:

Afrikaans (af), arabo (ar), armeno (hy), assamese (as), asturiano (ast), azero (az), bielorusso (be), bengalese (bn), bosniaco (bs), bulgaro (bg), birmano (my), cantonese (yue), catalano (ca), cebuano (ceb), croato (hr), ceco (cs), danese (da), olandese (nl), inglese (en), estone (et), filippino (fil), finlandese (fi), francese (fr), galiziano (gl), georgiano (ka), tedesco (de), greco (el), gujarati (gu), hausa (ha), ebraico (he), hindi (hi), ungherese (hu), islandese (is), indonesiano (id), irlandese (ga), italiano (it), giapponese (ja), giavanese (jv), kannada (kn), kazako (kk), coreano (ko), kirghiso (ky), lettone (lv), lingala (ln), lituano (lt), lussemburghese (lb), macedone (mk), malese (ms), malayalam (ml), maltese (mt), cinese mandarino (zh), māori (mi), marathi (mr), mongolo (mn), nepalese (ne), norvegese (no), occitano (oc), odia (or), pashtu (ps), persiano (fa), polacco (pl), portoghese (pt), punjabi (pa), rumeno (ro), russo (ru), serbo (sr), sindhi (sd), slovacco (sk), sloveno (sl), somalo (so), spagnolo (es), swahili (sw), svedese (sv), tagico (tg), tamil (ta), telugu (te), thai (th), turco (tr), ucraino (uk), urdu (ur), uzbeko (uz), vietnamita (vi), gallese (cy), yoruba (yo).

Eleven v3

Eleven v3 è il nostro modello di sintesi vocale della generazione precedente, che produce parlato naturale e realistico con un’ampia gamma emotiva e comprensione del contesto in più lingue.

Con Eleven v3 arriva una nuova Text to Dialogue API, che ti consente di generare dialoghi naturali e realistici, con un’ampia gamma emotiva e comprensione del contesto in più lingue. Puoi anche usare Eleven v3 con la Text to Speech API per generare parlato naturale e realistico, con un’ampia gamma emotiva e comprensione del contesto in più lingue.

Leggi di più sulla Text to Dialogue API qui.

Lingue supportate

Il modello Eleven v3 supporta oltre 70 lingue, tra cui:

Afrikaans (af), arabo (ar), armeno (hy), assamese (as), asturiano (ast), azero (az), bielorusso (be), bengalese (bn), bosniaco (bs), bulgaro (bg), birmano (my), cantonese (yue), catalano (ca), cebuano (ceb), chichewa (ny), croato (hr), ceco (cs), danese (da), olandese (nl), inglese (en), estone (et), filippino (fil), finlandese (fi), francese (fr), galiziano (gl), georgiano (ka), tedesco (de), greco (el), gujarati (gu), hausa (ha), ebraico (he), hindi (hi), ungherese (hu), islandese (is), indonesiano (id), irlandese (ga), italiano (it), giapponese (ja), giavanese (jv), kannada (kn), kazako (kk), kirghiso (ky), coreano (ko), lettone (lv), lingala (ln), lituano (lt), lussemburghese (lb), macedone (mk), malese (ms), malayalam (ml), maltese (mt), cinese mandarino (zh), māori (mi), marathi (mr), mongolo (mn), nepalese (ne), norvegese (no), occitano (oc), odia (or), pashtu (ps), persiano (fa), polacco (pl), portoghese (pt), punjabi (pa), rumeno (ro), russo (ru), serbo (sr), sindhi (sd), slovacco (sk), sloveno (sl), somalo (so), spagnolo (es), swahili (sw), svedese (sv), tagico (tg), tamil (ta), telugu (te), thai (th), turco (tr), ucraino (uk), urdu (ur), uzbeko (uz), vietnamita (vi), gallese (cy), yoruba (yo).

Eleven v3 Conversational

Eleven v3 Conversational è il nostro modello della generazione precedente per la sintesi vocale in tempo reale. Produce parlato naturale e realistico con un’ampia gamma emotiva e comprensione del contesto in più lingue.

Con Eleven v3 Conversational arriva un nuovo WebSocket Text to Dialogue, che ti consente di generare dialoghi naturali e realistici, con un’ampia gamma emotiva e comprensione del contesto in più lingue.

Con Eleven v3 Conversational arriva un nuovo WebSocket Text to Dialogue, che ti consente di generare dialoghi naturali e realistici, con un’ampia gamma emotiva e comprensione del contesto in più lingue.

Leggi di più sul WebSocket Text to Dialogue qui.

Lingue supportate

Il modello Eleven v3 supporta oltre 70 lingue, tra cui:

Afrikaans (af), arabo (ar), armeno (hy), assamese (as), asturiano (ast), azero (az), bielorusso (be), bengalese (bn), bosniaco (bs), bulgaro (bg), birmano (my), cantonese (yue), catalano (ca), cebuano (ceb), chichewa (ny), croato (hr), ceco (cs), danese (da), olandese (nl), inglese (en), estone (et), filippino (fil), finlandese (fi), francese (fr), galiziano (gl), georgiano (ka), tedesco (de), greco (el), gujarati (gu), hausa (ha), ebraico (he), hindi (hi), ungherese (hu), islandese (is), indonesiano (id), irlandese (ga), italiano (it), giapponese (ja), giavanese (jv), kannada (kn), kazako (kk), kirghiso (ky), coreano (ko), lettone (lv), lingala (ln), lituano (lt), lussemburghese (lb), macedone (mk), malese (ms), malayalam (ml), maltese (mt), cinese mandarino (zh), māori (mi), marathi (mr), mongolo (mn), nepalese (ne), norvegese (no), occitano (oc), odia (or), pashtu (ps), persiano (fa), polacco (pl), portoghese (pt), punjabi (pa), rumeno (ro), russo (ru), serbo (sr), sindhi (sd), slovacco (sk), sloveno (sl), somalo (so), spagnolo (es), swahili (sw), svedese (sv), tagico (tg), tamil (ta), telugu (te), thai (th), turco (tr), ucraino (uk), urdu (ur), uzbeko (uz), vietnamita (vi), gallese (cy), yoruba (yo).

Multilingual v2

Eleven Multilingual v2 è un modello di sintesi vocale della generazione precedente, in grado di riconoscere le emozioni. Produce parlato naturale e realistico con un’ampia gamma emotiva e comprensione del contesto in più lingue.

Il modello offre una qualità vocale e una personalità coerenti in tutte le lingue supportate, preservando al contempo le caratteristiche uniche e l’accento del parlante.

Questo modello eccelle negli scenari che richiedono parlato di alta qualità con sfumature emotive:

• Voci fuori campo per personaggi: Ideale per giochi e animazione grazie alla sua ampia gamma emotiva.
• Contenuti professionali: Adatto a video aziendali e materiali di e-learning.
• Progetti multilingue: Mantiene una qualità vocale coerente nei passaggi tra le lingue.
• Qualità stabile: Produce un output audio coerente e di alta qualità.

Sebbene abbia una latenza e un costo per carattere maggiori rispetto ai modelli Flash, offre una qualità superiore per i progetti in cui è importante un parlato realistico.

I nostri modelli multilingue v2 supportano 29 lingue:

inglese (Stati Uniti, Regno Unito, Australia, Canada), giapponese, cinese, tedesco, hindi, francese (Francia, Canada), coreano, portoghese (Brasile, Portogallo), italiano, spagnolo (Spagna, Messico), indonesiano, olandese, turco, filippino, polacco, svedese, bulgaro, rumeno, arabo (Arabia Saudita, Emirati Arabi Uniti), ceco, greco, finlandese, croato, malese, slovacco, danese, tamil, ucraino e russo.

Flash v2.5

Eleven Flash v2.5 è il nostro modello di sintesi vocale più veloce, progettato per applicazioni in tempo reale e Agents Platform. Offre parlato di alta qualità con latenza ultra bassa (~75ms†) in 32 lingue.

Il modello bilancia velocità e qualità, risultando ideale per le applicazioni interattive e mantenendo un output naturale e caratteristiche vocali coerenti tra le lingue.

Questo modello è particolarmente adatto per:

• Agents Platform: Perfetto per agenti vocali e chatbot in tempo reale.
• Applicazioni interattive: Ideale per giochi e applicazioni che richiedono una risposta immediata.
• Elaborazione su larga scala: Efficiente per la conversione in blocco da testo a parlato.

Grazie al prezzo più basso per le generazioni API e alla latenza di 75 ms, Flash v2.5 è l’opzione conveniente per chiunque abbia bisogno di sintesi vocale veloce e affidabile in più lingue.

Flash v2.5 supporta 32 lingue: tutte le lingue dei modelli v2, più:

ungherese, norvegese e vietnamita

Considerazioni

Guida alla scelta del modello

Per capire quale modello si adatta meglio ai tuoi requisiti e al tuo caso d’uso, consulta la guida alla scelta del modello.

Limiti di caratteri

Il numero massimo di caratteri supportati in una singola richiesta di sintesi vocale varia in base al modello.

Scribe v2

Scribe v2 è il nostro modello all’avanguardia di riconoscimento vocale, progettato per una trascrizione accurata in oltre 90 lingue. Fornisce timestamp precisi a livello di parola e funzionalità avanzate come la diarizzazione dei parlanti e il tagging audio dinamico.

Questo modello eccelle negli scenari che richiedono una conversione accurata da parlato a testo:

• Servizi di trascrizione: Perfetto per convertire contenuti audio/video in testo
• Documentazione delle riunioni: Ideale per acquisire e documentare conversazioni
• Analisi dei contenuti: Adatto all’elaborazione e all’analisi di contenuti audio
• Riconoscimento multilingue: Supporta una trascrizione accurata in oltre 90 lingue

Funzionalità principali:

• Trascrizione accurata con timestamp a livello di parola
• Diarizzazione dei parlanti per audio con più interlocutori
• Tagging audio dinamico per un contesto più ricco
• Supporto per oltre 90 lingue
• Rilevamento delle entità
• Prompting delle keyterm
• Modifica delle trascrizioni

Leggi di più su Scribe v2 qui.

Scribe v2 Realtime

Scribe v2 Realtime, il nostro modello più veloce e accurato di riconoscimento vocale in diretta, offre accuratezza all’avanguardia in oltre 90 lingue con una latenza ultra bassa di 150 ms.

Questo modello eccelle nei casi d’uso conversazionali:

• Trascrizione di riunioni in diretta: Perfetto per la trascrizione in tempo reale
• Agenti IA: Ideale per conversazioni in diretta
• Riconoscimento multilingue: Supporta una trascrizione accurata in oltre 90 lingue con riconoscimento automatico della lingua

Funzionalità principali:

• Latenza ultra bassa: ottieni trascrizioni parziali in circa 150 millisecondi
• Supporto per lo streaming: invia audio in blocchi mentre ricevi trascrizioni in tempo reale
• Più formati audio: supporto per codifica PCM (da 8 kHz a 48 kHz) e μ-law
• Voice Activity Detection (VAD): segmentazione automatica del parlato basata sul rilevamento del silenzio
• Controllo manuale del commit: controllo completo su quando finalizzare i segmenti della trascrizione
• Rilevamento delle entità
• Modifica delle trascrizioni

Leggi di più su Scribe v2 Realtime qui.

Scribe v2 Medical

Scribe v2 Medical è un modello batch di riconoscimento vocale specializzato per audio medici e clinici. È un finetune di Scribe v2 che migliora il riconoscimento dei nomi dei farmaci, dell’anatomia, della patologia e della dettatura clinica, mantenendo la stessa accuratezza di Scribe v2 sul parlato quotidiano. Usa la stessa Speech to Text API di Scribe v2 e ha la stessa tariffa. Passa scribe_v2_medical come model_id.

Questo modello è adatto per:

• Documentazione clinica: Consultazioni ambientali e note in cui i termini medici emergono nel corso della conversazione
• Dettatura: Sequenze dense di farmaci, dosaggi e risultati
• Chiamate di accettazione e coordinamento: Pazienti che descrivono le proprie condizioni, spesso al telefono
• Workflow di conformità normativa: Abbinalo al rilevamento delle entità per le categorie PHI

Funzionalità principali:

• Stessa struttura della richiesta di Scribe v2 (keyterms, entity_detection, no_verbatim, diarizzazione, timestamp)
• Riconoscimento migliorato di nomi di farmaci e termini relativi ad anatomia e patologia
• Nessuna regressione sul parlato quotidiano rispetto a Scribe v2
• Supporto per oltre 90 lingue
• Diarizzazione dei parlanti per audio con più interlocutori
• Tagging audio dinamico
• Rilevamento delle entità, incluse le categorie PHI

Scribe v2 Medical è un modello batch. Per la trascrizione in diretta, usa Scribe v2 Realtime.

Scribe v2 Medical è idoneo per HIPAA, con Business Associate Agreement disponibili per i clienti Enterprise e Zero Retention Mode (ZRM). Con ZRM abilitata, l’input audio e l’output testuale vengono eliminati immediatamente al completamento di ogni richiesta. ElevenLabs non conserva nulla e la tua applicazione riceve la risposta API completa, conservando le trascrizioni sotto il tuo controllo.

Leggi di più su Speech to Text qui.

Eleven Realtime

Eleven Realtime è una nuova classe di modelli Speech to Speech per creare agenti vocali naturali. Ogni modello Realtime è un agente vocale completo: riconoscimento vocale, rilevamento dell’attività vocale e gestione dei turni di parola, LLM e sintesi vocale, selezionati e ottimizzati da ElevenLabs affinché funzionino insieme come un unico sistema. Seleziona un modello Realtime per ottenere un agente dalle prestazioni elevate con una sola scelta, senza componenti da configurare.

Sono disponibili due modelli Realtime.

Eleven Realtime v1 Mini è ottimizzato per conversazioni rapide e naturali e funziona bene nei seguenti scenari:

• Assistenti IA: Dialoghi veloci ed espressivi in cui la conversazione stessa è il prodotto.
• Tutor educativi: Scambi naturali al passo con l’apprendimento dell’utente.
• Personaggi interattivi: Personaggi espressivi per giochi e intrattenimento.

Eleven Realtime v1 Max è ottimizzato per attività complesse e funziona bene nei seguenti scenari:

• Assistenza clienti: Risoluzione di richieste che richiedono di seguire una procedura e cercare informazioni.
• Qualificazione dei lead: Conversazioni strutturate che raccolgono informazioni e decidono i passaggi successivi.
• Workflow in più passaggi: Attività che chiamano strumenti per cercare informazioni o eseguire azioni.

Funzionalità principali:

• Riconoscimento vocale, gestione dei turni di parola, modello linguistico e voce in un’unica scelta del modello
• Gestione naturale dei turni di parola e delle interruzioni
• Chiamate di strumenti
• Voci personalizzabili dalla Voice Library di ElevenLabs
• Supporto per oltre 90 lingue
• Passa da v1 Mini a v1 Max selezionando un modello, senza modificare l’integrazione

Eleven Realtime è disponibile in ElevenAgents, dove selezioni un modello Realtime dal menu a discesa dei modelli, e tramite la Realtime API, progettata per essere compatibile con la Realtime API di OpenAI su WebSocket. Se usi già la Realtime API di OpenAI, consulta la guida alla migrazione.

Lingue supportate

I modelli Realtime supportano oltre 90 lingue. Consulta l’elenco delle lingue di Eleven v4.

Leggi di più su Eleven Realtime qui.

Eleven Music

Eleven Music è il nostro modello di generazione musicale di qualità da studio. Ti consente di generare musica in qualsiasi stile usando prompt in linguaggio naturale.

Questo modello è eccellente per i seguenti scenari:

• Colonne sonore per giochi: Crea colonne sonore coinvolgenti per i giochi
• Musica di sottofondo per podcast: Migliora i podcast con musica professionale
• Marketing: Aggiungi musica di sottofondo ai reel pubblicitari

Funzionalità principali:

• Controllo completo su genere, stile e struttura
• Voce o solo strumentale
• Multilingue, incluse inglese, spagnolo, tedesco, giapponese e altre lingue
• Modifica il suono e il testo delle singole sezioni o dell’intero brano

Leggi di più su Eleven Music qui.

Concorrenza e priorità

Il tuo piano di abbonamento determina quante richieste possono essere elaborate contemporaneamente e il livello di priorità delle tue richieste nella coda. Speech to Text ha un limite di concorrenza più elevato. Una volta raggiunto il limite di concorrenza, le richieste successive vengono elaborate in una coda insieme alle richieste con priorità più bassa. In pratica, questo aggiunge in genere solo ~50 ms di latenza.

Gli header della risposta includono current-concurrent-requests e maximum-concurrent-requests, che puoi usare per monitorare la concorrenza.

Richieste API al minuto e richieste concorrenti

È importante capire che le richieste API al minuto e le richieste concorrenti sono metriche diverse, che dipendono dai tuoi modelli di utilizzo.

Il numero di richieste API al minuto può essere diverso da quello delle richieste concorrenti, poiché dipende dalla durata di ogni richiesta e da come vengono raggruppate.

Esempio 1: richieste distanziate Se avessi 180 richieste al minuto, ciascuna della durata di 1 secondo, e le inviassi a intervalli di 0,33 secondi, il numero massimo e medio di richieste concorrenti sarebbe 3, perché ce ne sarebbero sempre 3 in corso.

Esempio 2: richieste in batch Se invece avessi un modello di utilizzo diverso, ad esempio 180 richieste al minuto, ciascuna della durata di 3 secondi, ma tutte inviate contemporaneamente, il numero massimo di richieste concorrenti sarebbe 180 e la media sarebbe 9 (nei primi 3 secondi del minuto si verificherebbero 180 richieste contemporaneamente, negli ultimi 57 secondi 0 richieste).

Poiché il nostro sistema considera la concorrenza, le richieste al minuto sono meno importanti della durata di ciascuna richiesta e del modello con cui vengono inviate.

Il modo in cui vengono effettuate le richieste agli endpoint influisce sui limiti di concorrenza:

• Con HTTP, ogni richiesta conta singolarmente ai fini del tuo limite di concorrenza.
• Con il WebSocket Text to Speech, solo il tempo durante il quale il nostro modello genera audio conta ai fini del tuo limite di concorrenza. Questo significa che, per la maggior parte del tempo, un websocket aperto non conta affatto ai fini del tuo limite di concorrenza.
• I WebSocket Text to Dialogue funzionano in modo diverso: ogni connessione aperta riserva una sessione di dialogo da un pool separato per tutto il tempo in cui resta aperta e l’audio generato tramite la connessione non conta ai fini del tuo limite di concorrenza standard. Questo approccio è progettato per essere più semplice da comprendere: una connessione corrisponde a una sessione e i limiti delle sessioni di dialogo sono dimensionati per adattarsi a questa nuova metodologia di concorrenza. Consulta concorrenza Text to Dialogue.

Comprendere i limiti di concorrenza

Il limite di concorrenza associato al tuo piano non va interpretato come il numero massimo di conversazioni simultanee, chiamate telefoniche, voci fuori campo di personaggi e così via che possono essere gestite contemporaneamente. Il numero effettivo dipende da diversi fattori, tra cui le specifiche voci IA utilizzate e le caratteristiche del caso d’uso.

Come regola generale, un limite di concorrenza pari a 5 può in genere supportare fino a circa 100 trasmissioni audio simultanee.

Questo dipende dalla velocità con cui viene generato l’audio rispetto al tempo necessario per elaborare la richiesta TTS. Il diagramma seguente mostra un esempio di come sia possibile gestire 4 chiamate concorrenti con utenti diversi raggiungendo solo 2 richieste concorrenti.

Se in qualsiasi momento superi i limiti di concorrenza del tuo piano e hai il piano Enterprise, le richieste al modello potrebbero comunque riuscire, seppur più lentamente, in base alla capacità disponibile e senza garanzie.

Concorrenza Text to Dialogue

Le richieste Text to Dialogue vengono misurate in due modi diversi, a seconda di come chiami l’API:

• Gli endpoint HTTP (Crea dialogo e Trasmetti dialogo in streaming) vengono conteggiati ai fini del limite di concorrenza standard del tuo piano durante la generazione dell’audio, come qualsiasi altra richiesta Text to Speech.
• Gli endpoint WebSocket, come il WebSocket Text to Dialogue, vengono misurati come sessioni di dialogo. Una connessione aperta occupa una sessione di dialogo per tutto il tempo in cui resta aperta, indipendentemente dal fatto che l’audio venga generato o meno.

La misurazione basata sulle sessioni semplifica la pianificazione della capacità: una connessione corrisponde a una sessione, quindi il tuo utilizzo non varia in base all’attività di generazione. Poiché una sessione viene occupata per l’intera connessione e non solo durante la generazione dell’audio, i limiti delle sessioni di dialogo sono dimensionati per adattarsi a questa nuova metodologia di concorrenza.

Se apri una connessione quando tutte le sessioni di dialogo del tuo workspace sono in uso, la nuova connessione viene rifiutata con un errore too_many_concurrent_requests. Per liberare sessioni, chiudi le connessioni che non ti servono più: una connessione si chiude automaticamente anche dopo 20 secondi di inattività, a meno che tu non invii messaggi keep_alive.

Per monitorare le sessioni di dialogo, apri Sviluppatori in fondo alla barra laterale della dashboard, seleziona la scheda Analytics e visualizza la metrica Richieste concorrenti nella vista Utilizzo. Le sessioni di dialogo vengono riportate come serie separata, Sessioni Websocket TTD, distinta dalle altre richieste concorrenti.

Test di scalabilità dei limiti di concorrenza

I test di scalabilità possono essere utili per individuare problemi di scalabilità lato client e verificare che i limiti di concorrenza siano impostati correttamente per il tuo caso d’uso.

Ti consigliamo vivamente di testare workflow end-to-end il più possibile vicini all’utilizzo reale; la metodologia consigliata consiste nel simulare e misurare quanti utenti possono essere supportati. È importante:

• Simulare utenti, non richieste grezze
• Simulare il comportamento tipico degli utenti, ad esempio attendere il completamento della riproduzione audio, del parlato dell’utente o della trascrizione prima di effettuare richieste
• Aumentare lentamente il numero di utenti nell’arco di alcuni minuti
• Introdurre casualità nella tempistica delle richieste e nelle loro dimensioni
• Acquisire metriche di latenza ed eventuali codici di errore restituiti dall’API

Ad esempio, per testare un sistema di agenti progettato per supportare 100 conversazioni simultanee, creeresti fino a 100 singoli “utenti”, ognuno dei quali simula una conversazione. Le conversazioni consistono in genere in un ciclo ripetuto di circa 10 secondi in cui l’utente parla, seguiti da una chiamata all’API TTS per circa 150 caratteri, seguita da circa 10 secondi di riproduzione audio per l’utente. Pertanto, ogni utente dovrebbe seguire il modello di effettuare una chiamata API Text-to-Speech tramite websocket per 150 caratteri di testo ogni 20 secondi, introducendo una piccola casualità nel periodo di attesa e nel numero di caratteri richiesti. Il test consisterebbe nell’avviare un utente al secondo fino a raggiungere 100 utenti, quindi nel testare il sistema per un totale di 10 minuti per verificarne la stabilità complessiva.

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