Modelos

Modelos principais

Text to Speech

Speech to Text

Agentes de voz

Música

Visão geral dos modelos

A API da ElevenLabs oferece uma variedade de modelos de áudio otimizados para diferentes casos de uso, níveis de qualidade e requisitos de desempenho.

Modelos descontinuados

Eleven v4

O Eleven v4 é nosso modelo de síntese de fala de última geração, oferecendo áudio da mais alta qualidade, expressividade e controle sobre a interpretação das vozes. O Eleven v4 oferece suporte à clonagem de voz de alta fidelidade, com preservação confiável do locutor em gerações de textos longos.

Este modelo funciona bem nos seguintes cenários:

• Locuções de personagens: Ideal para jogos e animações devido à sua amplitude emocional.
• Diálogo emocional: Gere diálogos naturais e realistas, com alta amplitude emocional e compreensão contextual.
• Produção de audiolivros: Perfeito para narrações longas com interpretação emocional complexa.
• Projetos multilíngues: Mantém uma qualidade de voz consistente ao alternar entre idiomas.

O Eleven v4 está disponível pela API Text to Dialogue.

Idiomas compatíveis

A família de modelos Eleven v4 oferece suporte a mais de 90 idiomas, incluindo:

Africâner (af), Amárico (am), Árabe (ar), Armênio (hy), Assamês (as), Asturiano (ast), Azerbaijano (az), Bielorrusso (be), Bengali (bn), Bósnio (bs), Búlgaro (bg), Birmanês (my), Cantonês (yue), Catalão (ca), Cebuano (ceb), Croata (hr), Tcheco (cs), Dinamarquês (da), Holandês (nl), Inglês (en), Estoniano (et), Filipino (fil), Finlandês (fi), Francês (fr), Fula (Pulaar) (ff), Galego (gl), Georgiano (ka), Alemão (de), Grego (el), Guzerate (gu), Hauçá (ha), Hebraico (he), Hindi (hi), Húngaro (hu), Islandês (is), Indonésio (id), Italiano (it), Japonês (ja), Javanês (jv), Kamba (kam), Canarês (kn), Cazaque (kk), Coreano (ko), Quirguiz (ky), Laosiano (lo), Letão (lv), Lingala (ln), Lituano (lt), Luganda (lg), Luxemburguês (lb), Macedônio (mk), Malaio (ms), Malaiala (ml), Maltês (mt), Chinês mandarim (zh), Maori (mi), Marata (mr), Mongol (mn), Nepalês (ne), Norueguês (no), Occitano (oc), Odia (or), Pachto (ps), Persa (fa), Polonês (pl), Português (pt), Punjabi (pa), Romeno (ro), Russo (ru), Sérvio (sr), Xona (sn), Sindi (sd), Eslovaco (sk), Esloveno (sl), Somali (so), Curdo sorâni (ckb), Espanhol (es), Suaíli (sw), Sueco (sv), Tajique (tg), Tâmil (ta), Télugo (te), Tailandês (th), Turco (tr), Ucraniano (uk), Urdu (ur), Uzbeque (uz), Vietnamita (vi), Galês (cy), Uolofe (wo), Zulu (zu).

Eleven v4 Turbo

Eleven v4 Turbo é nosso modelo mais avançado para síntese de voz em tempo real, oferecendo áudio de alta qualidade, expressividade e controle sobre a interpretação das vozes. O Eleven v4 Turbo oferece suporte à clonagem de voz de alta fidelidade e tem latência mediana de ~100 ms. Veja como a latência é medida.

Este modelo funciona bem nos seguintes cenários:

• Agentes de suporte: Potencialize agentes de voz que resolvem dúvidas de clientes em tempo real.
• Assistentes de IA: Gere diálogos naturais e realistas com ampla gama emocional e compreensão contextual.
• Personagens interativos: Excelente para experiências de áudio com personagens expressivos.

O Eleven v4 Turbo está disponível pelo WebSocket de Text to Dialogue.

Idiomas compatíveis

A família de modelos Eleven v4 oferece suporte a mais de 90 idiomas, incluindo:

Africâner (af), Amárico (am), Árabe (ar), Armênio (hy), Assamês (as), Asturiano (ast), Azerbaijano (az), Bielorrusso (be), Bengali (bn), Bósnio (bs), Búlgaro (bg), Birmanês (my), Cantonês (yue), Catalão (ca), Cebuano (ceb), Croata (hr), Tcheco (cs), Dinamarquês (da), Holandês (nl), Inglês (en), Estoniano (et), Filipino (fil), Finlandês (fi), Francês (fr), Fula (Pulaar) (ff), Galego (gl), Georgiano (ka), Alemão (de), Grego (el), Guzerate (gu), Hauçá (ha), Hebraico (he), Hindi (hi), Húngaro (hu), Islandês (is), Indonésio (id), Italiano (it), Japonês (ja), Javanês (jv), Kamba (kam), Canarês (kn), Cazaque (kk), Coreano (ko), Quirguiz (ky), Laosiano (lo), Letão (lv), Lingala (ln), Lituano (lt), Luganda (lg), Luxemburguês (lb), Macedônio (mk), Malaio (ms), Malaiala (ml), Maltês (mt), Chinês mandarim (zh), Maori (mi), Marata (mr), Mongol (mn), Nepalês (ne), Norueguês (no), Occitano (oc), Odia (or), Pachto (ps), Persa (fa), Polonês (pl), Português (pt), Punjabi (pa), Romeno (ro), Russo (ru), Sérvio (sr), Xona (sn), Sindi (sd), Eslovaco (sk), Esloveno (sl), Somali (so), Curdo sorâni (ckb), Espanhol (es), Suaíli (sw), Sueco (sv), Tajique (tg), Tâmil (ta), Télugo (te), Tailandês (th), Turco (tr), Ucraniano (uk), Urdu (ur), Uzbeque (uz), Vietnamita (vi), Galês (cy), Uolofe (wo), Zulu (zu).

Eleven v3

O Eleven v3 é nosso modelo de síntese de voz da geração anterior, que produz fala natural e realista com ampla gama emocional e compreensão contextual em vários idiomas.

Com o Eleven v3, chega uma nova API de Text to Dialogue, que permite gerar diálogos naturais e realistas com ampla gama emocional e compreensão contextual em vários idiomas. O Eleven v3 também pode ser usado com a API de Text to Speech para gerar fala natural e realista com ampla gama emocional e compreensão contextual em vários idiomas.

Leia mais sobre a API de Text to Dialogue aqui.

Idiomas compatíveis

O modelo Eleven v3 oferece suporte a mais de 70 idiomas, incluindo:

Africâner (af), árabe (ar), armênio (hy), assamês (as), asturiano (ast), azerbaijano (az), bielorrusso (be), bengali (bn), bósnio (bs), búlgaro (bg), birmanês (my), cantonês (yue), catalão (ca), cebuano (ceb), chichewa (ny), croata (hr), tcheco (cs), dinamarquês (da), holandês (nl), inglês (en), estoniano (et), filipino (fil), finlandês (fi), francês (fr), galego (gl), georgiano (ka), alemão (de), grego (el), guzerate (gu), hauçá (ha), hebraico (he), hindi (hi), húngaro (hu), islandês (is), indonésio (id), irlandês (ga), italiano (it), japonês (ja), javanês (jv), canarês (kn), cazaque (kk), quirguiz (ky), coreano (ko), letão (lv), lingala (ln), lituano (lt), luxemburguês (lb), macedônio (mk), malaio (ms), malaiala (ml), maltês (mt), chinês mandarim (zh), maori (mi), marata (mr), mongol (mn), nepalês (ne), norueguês (no), occitano (oc), odia (or), pachto (ps), persa (fa), polonês (pl), português (pt), punjabi (pa), romeno (ro), russo (ru), sérvio (sr), sindi (sd), eslovaco (sk), esloveno (sl), somali (so), espanhol (es), suaíli (sw), sueco (sv), tadjique (tg), tâmil (ta), telugu (te), tailandês (th), turco (tr), ucraniano (uk), urdu (ur), uzbeque (uz), vietnamita (vi), galês (cy), iorubá (yo).

Eleven v3 Conversational

O Eleven v3 Conversational é nosso modelo da geração anterior para síntese de voz em tempo real. Ele produz fala natural e realista com ampla gama emocional e compreensão contextual em vários idiomas.

Com o Eleven v3 Conversational, chega um novo WebSocket de Text to Dialogue, que permite gerar diálogos naturais e realistas com ampla gama emocional e compreensão contextual em vários idiomas.

Com o Eleven v3 Conversational, chega um novo WebSocket de Text to Dialogue, que permite gerar diálogos naturais e realistas com ampla gama emocional e compreensão contextual em vários idiomas.

Leia mais sobre o WebSocket de Text to Dialogue aqui.

Idiomas compatíveis

O modelo Eleven v3 oferece suporte a mais de 70 idiomas, incluindo:

Africâner (af), árabe (ar), armênio (hy), assamês (as), asturiano (ast), azerbaijano (az), bielorrusso (be), bengali (bn), bósnio (bs), búlgaro (bg), birmanês (my), cantonês (yue), catalão (ca), cebuano (ceb), chichewa (ny), croata (hr), tcheco (cs), dinamarquês (da), holandês (nl), inglês (en), estoniano (et), filipino (fil), finlandês (fi), francês (fr), galego (gl), georgiano (ka), alemão (de), grego (el), guzerate (gu), hauçá (ha), hebraico (he), hindi (hi), húngaro (hu), islandês (is), indonésio (id), irlandês (ga), italiano (it), japonês (ja), javanês (jv), canarês (kn), cazaque (kk), quirguiz (ky), coreano (ko), letão (lv), lingala (ln), lituano (lt), luxemburguês (lb), macedônio (mk), malaio (ms), malaiala (ml), maltês (mt), chinês mandarim (zh), maori (mi), marata (mr), mongol (mn), nepalês (ne), norueguês (no), occitano (oc), odia (or), pachto (ps), persa (fa), polonês (pl), português (pt), punjabi (pa), romeno (ro), russo (ru), sérvio (sr), sindi (sd), eslovaco (sk), esloveno (sl), somali (so), espanhol (es), suaíli (sw), sueco (sv), tadjique (tg), tâmil (ta), telugu (te), tailandês (th), turco (tr), ucraniano (uk), urdu (ur), uzbeque (uz), vietnamita (vi), galês (cy), iorubá (yo).

Multilingual v2

O Eleven Multilingual v2 é um modelo de síntese de voz da geração anterior com percepção emocional. Ele produz fala natural e realista com ampla gama emocional e compreensão contextual em vários idiomas.

O modelo oferece qualidade de voz e personalidade consistentes em todos os idiomas compatíveis, mantendo as características únicas e o sotaque do falante.

Este modelo se destaca em cenários que exigem fala de alta qualidade e com nuances emocionais:

• Locuções de personagens: Ideal para jogos e animações devido à sua gama emocional.
• Conteúdo profissional: Adequado para vídeos corporativos e materiais de e-learning.
• Projetos multilíngues: Mantém uma qualidade de voz consistente ao alternar entre idiomas.
• Qualidade estável: Produz áudio consistente e de alta qualidade.

Embora tenha maior latência e custo por caractere do que os modelos Flash, ele oferece qualidade superior para projetos em que uma fala realista é importante.

Nossos modelos multilíngues v2 oferecem suporte a 29 idiomas:

Inglês (EUA, Reino Unido, Austrália, Canadá), Japonês, Chinês, Alemão, Hindi, Francês (França, Canadá), Coreano, Português (Brasil, Portugal), Italiano, Espanhol (Espanha, México), Indonésio, Holandês, Turco, Filipino, Polonês, Sueco, Búlgaro, Romeno, Árabe (Arábia Saudita, Emirados Árabes Unidos), Tcheco, Grego, Finlandês, Croata, Malaio, Eslovaco, Dinamarquês, Tâmil, Ucraniano e Russo.

Flash v2.5

O Eleven Flash v2.5 é um modelo de síntese de voz de baixa latência projetado para aplicações em tempo real e a Agents Platform. Ele oferece fala de alta qualidade com latência mediana de ~100 ms† em 32 idiomas.

O modelo equilibra velocidade e qualidade, tornando-o ideal para aplicações interativas e mantendo uma saída com som natural e características de voz consistentes entre idiomas.

Este modelo é especialmente adequado para:

• Agents Platform: Perfeito para agentes de voz e chatbots em tempo real.
• Aplicações interativas: Ideal para jogos e aplicações que exigem resposta imediata.
• Processamento em larga escala: Eficiente para conversão em massa de texto em fala.

Com preço mais baixo para gerações pela API e baixa latência, o Flash v2.5 é a opção econômica para quem precisa de síntese de voz rápida e confiável em vários idiomas.

O Flash v2.5 oferece suporte a 32 idiomas — todos os idiomas dos modelos v2, além de:

Húngaro, Norueguês e Vietnamita

Considerações

Guia de seleção de modelos

Para saber qual modelo atende melhor aos seus requisitos e caso de uso, consulte o guia de seleção de modelos.

Limites de caracteres

O número máximo de caracteres aceitos em uma única solicitação de texto para fala varia conforme o modelo.

Scribe v2

O Scribe v2 é nosso modelo mais avançado de reconhecimento de fala, desenvolvido para transcrição precisa em mais de 90 idiomas. Ele fornece timestamps precisos no nível das palavras e recursos avançados, como diarização de falantes e marcação dinâmica de áudio.

Este modelo se destaca em cenários que exigem conversão precisa de fala em texto:

• Serviços de transcrição: Perfeito para converter conteúdo de áudio/vídeo em texto
• Documentação de reuniões: Ideal para capturar e documentar conversas
• Análise de conteúdo: Adequado para processamento e análise de conteúdo de áudio
• Reconhecimento multilíngue: Oferece suporte a transcrição precisa em mais de 90 idiomas

Principais recursos:

• Transcrição precisa com timestamps no nível das palavras
• Diarização de falantes para áudio com vários falantes
• Marcação dinâmica de áudio para mais contexto
• Suporte a mais de 90 idiomas
• Detecção de entidades
• Orientação por termos-chave
• Edição de transcrições

Leia mais sobre o Scribe v2 aqui.

Scribe v2 Realtime

O Scribe v2 Realtime, nosso modelo mais rápido e preciso de reconhecimento de fala ao vivo, oferece precisão de ponta em mais de 90 idiomas, com tempo mediano até a transcrição confirmada de ~150 ms. Veja como a latência é medida.

Este modelo se destaca em casos de uso conversacionais:

• Transcrição de reuniões ao vivo: Perfeito para transcrição em tempo real
• Agentes de IA: Ideal para conversas ao vivo
• Reconhecimento multilíngue: Oferece suporte a transcrição precisa em mais de 90 idiomas com reconhecimento automático de idioma

Principais recursos:

• Latência ultrabaixa: obtenha transcrições confirmadas com latência mediana de ~150 milissegundos
• Suporte a streaming: envie áudio em partes enquanto recebe transcrições em tempo real
• Vários formatos de áudio: suporte a PCM (de 8 kHz a 48 kHz) e codificação μ-law
• Detecção de atividade de voz (VAD): segmentação automática de fala com base na detecção de silêncio
• Controle manual de confirmação: controle total sobre quando finalizar segmentos de transcrição
• Detecção de entidades
• Redação de entidades
• Edição de transcrições

Leia mais sobre o Scribe v2 Realtime aqui.

Scribe v2 Medical

O Scribe v2 Medical é um modelo de reconhecimento de fala em lote especializado em áudio médico e clínico. É um finetune do Scribe v2 que melhora o reconhecimento de nomes de medicamentos, anatomia, patologia e ditado clínico, mantendo a precisão do Scribe v2 na fala cotidiana. Ele usa a mesma API de Speech to Text do Scribe v2 e é cobrado pela mesma tarifa. Passe scribe_v2_medical como model_id.

Este modelo é adequado para:

• Documentação clínica: Consultas e anotações em ambiente clínico nas quais termos médicos surgem durante a conversa
• Ditado: Sequências densas de medicamentos, dosagens e achados
• Chamadas de triagem e coordenação: Pacientes descrevendo suas próprias condições, geralmente por telefone
• Fluxos de trabalho de conformidade: Combine com a detecção de entidades para categorias de PHI

Principais recursos:

• Mesma estrutura de solicitação do Scribe v2 (keyterms, entity_detection, no_verbatim, diarização, timestamps)
• Reconhecimento aprimorado de nomes de medicamentos, termos de anatomia e patologia
• Sem regressão na fala cotidiana em comparação com o Scribe v2
• Suporte a mais de 90 idiomas
• Diarização de falantes para áudio com vários falantes
• Marcação dinâmica de áudio
• Detecção de entidades, incluindo categorias de PHI

O Scribe v2 Medical é um modelo em lote. Para transcrição ao vivo, use o Scribe v2 Realtime.

O Scribe v2 Medical é elegível para HIPAA, com Acordos de Associado Comercial disponíveis para clientes Enterprise, além do Modo de Retenção Zero (ZRM). Com o ZRM ativado, a entrada de áudio e a saída de texto são excluídas imediatamente após a conclusão de cada solicitação. A ElevenLabs não retém nada, e sua aplicação recebe a resposta completa da API e mantém as transcrições sob seus próprios controles.

Leia mais sobre Speech to Text aqui.

SFX v3

O SFX v3 (eleven_text_to_sound_v3) é nosso mais novo modelo de efeitos sonoros. Ele usa a mesma API de Efeitos Sonoros que eleven_text_to_sound_v2: defina model_id como eleven_text_to_sound_v3 para usá-lo. eleven_text_to_sound_v2 ainda é o padrão, mas está obsoleto e será removido em 1º de março de 2027.

Em comparação com eleven_text_to_sound_v2, o SFX v3:

• Segue várias instruções em um único prompt, como “Torcida de futebol comemorando, som de uma bola caindo, torcida vaiando”.
• Processa prompts que incluem música ou vocais, como “Coral gospel cantando olá”.
• Produz resultados com som mais natural.
• Tem menos probabilidade de causar clipping em sons de alta frequência, como gongos, sinos e apitos.

Os resultados variam conforme o prompt, então compare os dois modelos com seus próprios prompts antes de fazer a troca.

O SFX v3 oferece suporte a repetição. Defina loop como true para gerar um efeito sonoro que se repete suavemente.

No ElevenCreative, o SFX v3 está disponível em Efeitos Sonoros, Flows e Estúdio.

Leia mais sobre efeitos sonoros aqui.

Eleven Realtime

O Eleven Realtime é uma nova classe de modelos de Speech to Speech para criar agentes de voz naturais. Cada modelo Realtime é um agente de voz completo: reconhecimento de fala, detecção de atividade de voz e gerenciamento de turnos, LLM e texto para fala, selecionados e ajustados pela ElevenLabs para funcionar juntos como um único sistema. Selecione um modelo Realtime e você terá um agente com bom desempenho a partir de uma única escolha, sem componentes para configurar.

Há dois modelos Realtime disponíveis.

O Eleven Realtime v1 Mini é otimizado para conversas rápidas e naturais e funciona bem nos seguintes cenários:

• Assistentes de IA: Diálogos rápidos e expressivos em que a própria conversa é o produto.
• Tutores educacionais: Interações naturais que acompanham o ritmo do aluno.
• Personagens interativos: Personagens expressivos para jogos e entretenimento.

O Eleven Realtime v1 Max é otimizado para tarefas complexas e funciona bem nos seguintes cenários:

• Suporte ao cliente: Resolução de dúvidas que exigem seguir um processo e buscar informações.
• Qualificação de leads: Conversas estruturadas que coletam informações e definem os próximos passos.
• Fluxos de trabalho com várias etapas: Tarefas que chamam ferramentas para buscar informações ou executar ações.

Principais recursos:

• Reconhecimento de fala, gerenciamento de turnos, modelo de linguagem e voz em uma única escolha de modelo
• Gerenciamento natural de turnos e interrupções
• Chamada de ferramentas
• Vozes personalizáveis da Voice Library da ElevenLabs
• Suporte a mais de 90 idiomas
• Alterne entre v1 Mini e v1 Max com uma seleção de modelo, sem mudar a integração

O Eleven Realtime está disponível no ElevenAgents, onde você seleciona um modelo Realtime no menu suspenso de modelos, e pela API Realtime, projetada para ser compatível com a API Realtime da OpenAI por WebSocket. Se você já usa a API Realtime da OpenAI, consulte o guia de migração.

Idiomas compatíveis

Os modelos Realtime oferecem suporte a mais de 90 idiomas. Veja a lista de idiomas do Eleven v4.

Leia mais sobre o Eleven Realtime aqui.

Eleven Music

O Eleven Music é nosso modelo de geração de música com qualidade de estúdio. Ele permite gerar música de qualquer estilo com prompts em linguagem natural.

Este modelo é excelente para os seguintes cenários:

• Trilhas sonoras de jogos: Crie trilhas imersivas para jogos
• Música de fundo para podcasts: Aprimore podcasts com música profissional
• Marketing: Adicione música de fundo a vídeos de anúncios

Principais recursos:

• Controle completo sobre gênero, estilo e estrutura
• Vocais ou somente instrumental
• Multilíngue, incluindo inglês, espanhol, alemão, japonês e muito mais
• Edite o som e a letra de seções individuais ou da música inteira

Leia mais sobre o Eleven Music aqui.

Simultaneidade e prioridade

Seu plano de assinatura determina quantas solicitações podem ser processadas simultaneamente e o nível de prioridade das suas solicitações na fila. O Speech to Text tem um limite de simultaneidade maior. Quando o limite de simultaneidade é atingido, as solicitações subsequentes são processadas em uma fila junto com solicitações de menor prioridade. Na prática, isso normalmente adiciona apenas cerca de 50 ms de latência.

Os cabeçalhos de resposta incluem current-concurrent-requests e maximum-concurrent-requests, que você pode usar para monitorar sua simultaneidade.

Solicitações da API por minuto vs. solicitações simultâneas

É importante entender que solicitações da API por minuto e solicitações simultâneas são métricas diferentes que dependem dos seus padrões de uso.

As solicitações da API por minuto podem ser diferentes das solicitações simultâneas, pois isso depende da duração de cada solicitação e de como elas são agrupadas.

Exemplo 1: Solicitações espaçadas Se você tivesse 180 solicitações por minuto, cada uma levando 1 segundo para ser concluída, e as enviasse com intervalos de 0,33 segundo, o máximo de solicitações simultâneas seria 3 e a média também seria 3, pois sempre haveria 3 em andamento.

Exemplo 2: Solicitações em lote No entanto, se você tivesse um padrão de uso diferente, como 180 solicitações por minuto, cada uma levando 3 segundos para ser concluída, mas todas disparadas de uma vez, o máximo de solicitações simultâneas seria 180 e a média seria 9 (nos primeiros 3 segundos do minuto haveria 180 solicitações de uma vez; nos 57 segundos finais, 0 solicitações).

Como nosso sistema considera a simultaneidade, as solicitações por minuto são menos importantes do que a duração de cada solicitação e o padrão de quando elas são enviadas.

A forma como as solicitações aos endpoints são feitas afeta os limites de simultaneidade:

• Com HTTP, cada solicitação conta individualmente para seu limite de simultaneidade.
• Com o WebSocket de Text to Speech, somente o tempo em que nosso modelo está gerando áudio conta para seu limite de simultaneidade. Isso significa que, na maior parte do tempo, um websocket aberto não conta para seu limite de simultaneidade.
• Os WebSockets de Text to Dialogue funcionam de forma diferente: cada conexão aberta reserva uma sessão de diálogo de um pool separado enquanto permanecer aberta, e o áudio gerado pela conexão não conta para seu limite padrão de simultaneidade. Isso foi pensado para ser mais fácil de entender: uma conexão equivale a uma sessão, e seus limites de sessão de diálogo são dimensionados para se ajustar a essa nova metodologia de simultaneidade. Consulte simultaneidade do Text to Dialogue.

Entendendo os limites de simultaneidade

O limite de simultaneidade associado ao seu plano não deve ser interpretado como o número máximo de conversas, chamadas telefônicas, locuções de personagens etc. que podem ser atendidas ao mesmo tempo. O número real depende de vários fatores, incluindo as vozes IA específicas usadas e as características do caso de uso.

Como regra geral, um limite de simultaneidade de 5 normalmente pode atender a até aproximadamente 100 transmissões de áudio simultâneas.

Isso se deve à velocidade de geração do áudio em relação ao tempo necessário para processar a solicitação de TTS. O diagrama abaixo mostra um exemplo de como 4 chamadas simultâneas com usuários diferentes podem ser atendidas usando apenas 2 solicitações simultâneas.

Se você exceder os limites de simultaneidade do seu plano em algum momento e estiver no plano Enterprise, as solicitações de modelo ainda poderão ser bem-sucedidas, embora mais lentas, conforme a capacidade disponível e sem garantia.

Simultaneidade do Text to Dialogue

As solicitações de Text to Dialogue são medidas de duas formas diferentes, dependendo de como você chama a API:

• Endpoints HTTP (Criar diálogo e Transmitir diálogo) contam para o limite padrão de simultaneidade do seu plano enquanto o áudio é gerado, como qualquer outra solicitação de Text to Speech.
• Endpoints WebSocket, como o WebSocket de Text to Dialogue, são medidos como sessões de diálogo. Uma conexão aberta ocupa uma sessão de diálogo enquanto permanecer aberta, independentemente de o áudio estar sendo gerado no momento.

A medição baseada em sessão simplifica o planejamento de capacidade: uma conexão equivale a uma sessão, então seu uso não varia com a atividade de geração. Como uma sessão é ocupada durante toda a conexão, e não apenas enquanto o áudio é gerado, seus limites de sessão de diálogo são dimensionados para se ajustar a essa nova metodologia de simultaneidade.

Se você abrir uma conexão enquanto todas as sessões de diálogo do seu espaço de trabalho estiverem em uso, a nova conexão será rejeitada com o erro too_many_concurrent_requests. Para liberar sessões, feche as conexões de que você não precisa mais — uma conexão também é fechada automaticamente após 20 segundos de inatividade, a menos que você envie mensagens keep_alive.

Para monitorar as sessões de diálogo, abra Desenvolvedores na parte inferior da barra lateral do painel, selecione a aba Analytics e veja a métrica Solicitações simultâneas na visualização Uso. As sessões de diálogo são informadas em sua própria série, TTD Websocket Sessions, separadas das suas outras solicitações simultâneas.

Teste de carga dos limites de simultaneidade

O teste de carga pode ser útil para identificar problemas de escalabilidade no lado do cliente e verificar se os limites de simultaneidade estão configurados corretamente para seu caso de uso.

É altamente recomendável testar fluxos de trabalho de ponta a ponta o mais próximo possível do uso real. A metodologia recomendada para isso é simular e medir quantos usuários podem ser atendidos. É importante:

• Simular usuários, não solicitações brutas
• Simular o comportamento típico dos usuários, como esperar a reprodução do áudio, a fala do usuário ou a transcrição terminar antes de fazer solicitações
• Aumentar o número de usuários gradualmente ao longo de alguns minutos
• Introduzir aleatoriedade no momento das solicitações e no tamanho delas
• Capturar métricas de latência e eventuais códigos de erro retornados pela API

Por exemplo, para testar um sistema de agentes desenvolvido para atender 100 conversas simultâneas, você criaria até 100 “usuários” individuais, cada um simulando uma conversa. As conversas normalmente consistem em um ciclo repetido de cerca de 10 segundos de fala do usuário, seguido por uma chamada à API de TTS para cerca de 150 caracteres, seguida por cerca de 10 segundos de reprodução de áudio para o usuário. Portanto, cada usuário deve seguir o padrão de fazer uma chamada à API de Text to Speech via websocket para 150 caracteres de texto a cada 20 segundos, introduzindo uma pequena quantidade de aleatoriedade no período de espera e no número de caracteres solicitados. O teste consistiria em iniciar um usuário por segundo até que existam 100 e, então, testar por 10 minutos no total para avaliar a estabilidade geral.

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