モデル

フラッグシップモデル

テキスト読み上げ

スピーチtoテキスト

音楽

モデル概要

ElevenLabs APIは、さまざまなユースケース、品質レベル、パフォーマンス要件に対応するオーディオモデルを提供しています。

非推奨モデル

Eleven v4

Eleven v4は最先端の音声合成モデルで、最高品質のオーディオ、表現力、音声の演技に対するコントロールを提供します。Eleven v4は高忠実度のボイスクローンに対応し、長文の生成でも話者の特徴を確実に維持します。

このモデルは、次のシナリオに適しています。

• キャラクターボイスオーバー：感情表現の幅が広く、ゲームやアニメーションに最適です。
• 感情豊かな会話：幅広い感情表現と文脈理解を備えた、自然で生き生きとした会話を生成します。
• オーディオブック制作：複雑な感情表現を伴う長尺のナレーションに最適です。
• 多言語プロジェクト：言語を切り替えても一貫した音声品質を維持します。

Eleven v4はテキストtoダイアログAPIで利用できます。

対応言語

Eleven v4モデルファミリーは、以下を含む90以上の言語に対応しています：

アフリカーンス語（afr）、アムハラ語（amh）、アラビア語（ara）、アルメニア語（hye）、アッサム語（asm）、アストゥリアス語（ast）、アゼルバイジャン語（aze）、ベラルーシ語（bel）、ベンガル語（ben）、ボスニア語（bos）、ブルガリア語（bul）、ビルマ語（mya）、広東語（yue）、カタルーニャ語（cat）、セブアノ語（ceb）、クロアチア語（hrv）、チェコ語（ces）、デンマーク語（dan）、オランダ語（nld）、英語（eng）、エストニア語（est）、フィリピノ語（fil）、フィンランド語（fin）、フランス語（fra）、フラ語／プラール語（ful）、ガリシア語（glg）、ジョージア語（kat）、ドイツ語（deu）、ギリシャ語（ell）、グジャラート語（guj）、ハウサ語（hau）、ヘブライ語（heb）、ヒンディー語（hin）、ハンガリー語（hun）、アイスランド語（isl）、インドネシア語（ind）、イタリア語（ita）、日本語（jpn）、ジャワ語（jav）、カンバ語（kam）、カンナダ語（kan）、カザフ語（kaz）、韓国語（kor）、キルギス語（kir）、ラオ語（lao）、ラトビア語（lav）、リンガラ語（lin）、リトアニア語（lit）、ルガンダ語（lug）、ルクセンブルク語（ltz）、マケドニア語（mkd）、マレー語（msa）、マラヤーラム語（mal）、マルタ語（mlt）、中国語（標準語）（cmn）、マオリ語（mri）、マラーティー語（mar）、モンゴル語（mon）、ネパール語（nep）、ノルウェー語（ブークモール）（nob）、オック語（oci）、オディア語（ori）、パシュトー語（pus）、ペルシャ語（fas）、ポーランド語（pol）、ポルトガル語（ブラジル）（por）、パンジャブ語（pan）、ルーマニア語（ron）、ロシア語（rus）、セルビア語（srp）、ショナ語（sna）、シンド語（snd）、スロバキア語（slk）、スロベニア語（slv）、ソマリ語（som）、ソラニー・クルド語（ckb）、スペイン語（中南米）（spa）、スワヒリ語（swa）、スウェーデン語（swe）、タジク語（tgk）、タミル語（tam）、テルグ語（tel）、タイ語（tha）、トルコ語（tur）、ウクライナ語（ukr）、ウルドゥー語（urd）、ウズベク語（uzb）、ベトナム語（vie）、ウェールズ語（cym）、ウォロフ語（wol）、ズールー語（zul）。

Eleven v4 Turbo

Eleven v4 Turboは、リアルタイム音声合成向けの最先端モデルで、高品質なオーディオ、表現力、音声の演技に対するコントロールを提供します。Eleven v4 Turboは高忠実度のボイスクローンに対応し、推論レイテンシーの中央値約100msで結果を提供します。

このモデルは、次のシナリオに適しています。

• サポートエージェント：顧客からの問い合わせをリアルタイムで解決する音声エージェントを実現します。
• AIアシスタント：幅広い感情表現と文脈理解を備えた、自然で生き生きとした会話を生成します。
• インタラクティブキャラクター：表現力豊かなキャラクターを使ったオーディオ体験に最適です。

Eleven v4 TurboはテキストtoダイアログWebSocketで利用できます。

対応言語

Eleven v4モデルファミリーは、以下を含む90以上の言語に対応しています：

アフリカーンス語（afr）、アムハラ語（amh）、アラビア語（ara）、アルメニア語（hye）、アッサム語（asm）、アストゥリアス語（ast）、アゼルバイジャン語（aze）、ベラルーシ語（bel）、ベンガル語（ben）、ボスニア語（bos）、ブルガリア語（bul）、ビルマ語（mya）、広東語（yue）、カタルーニャ語（cat）、セブアノ語（ceb）、クロアチア語（hrv）、チェコ語（ces）、デンマーク語（dan）、オランダ語（nld）、英語（eng）、エストニア語（est）、フィリピノ語（fil）、フィンランド語（fin）、フランス語（fra）、フラ語／プラール語（ful）、ガリシア語（glg）、ジョージア語（kat）、ドイツ語（deu）、ギリシャ語（ell）、グジャラート語（guj）、ハウサ語（hau）、ヘブライ語（heb）、ヒンディー語（hin）、ハンガリー語（hun）、アイスランド語（isl）、インドネシア語（ind）、イタリア語（ita）、日本語（jpn）、ジャワ語（jav）、カンバ語（kam）、カンナダ語（kan）、カザフ語（kaz）、韓国語（kor）、キルギス語（kir）、ラオ語（lao）、ラトビア語（lav）、リンガラ語（lin）、リトアニア語（lit）、ルガンダ語（lug）、ルクセンブルク語（ltz）、マケドニア語（mkd）、マレー語（msa）、マラヤーラム語（mal）、マルタ語（mlt）、中国語（標準語）（cmn）、マオリ語（mri）、マラーティー語（mar）、モンゴル語（mon）、ネパール語（nep）、ノルウェー語（ブークモール）（nob）、オック語（oci）、オディア語（ori）、パシュトー語（pus）、ペルシャ語（fas）、ポーランド語（pol）、ポルトガル語（ブラジル）（por）、パンジャブ語（pan）、ルーマニア語（ron）、ロシア語（rus）、セルビア語（srp）、ショナ語（sna）、シンド語（snd）、スロバキア語（slk）、スロベニア語（slv）、ソマリ語（som）、ソラニー・クルド語（ckb）、スペイン語（中南米）（spa）、スワヒリ語（swa）、スウェーデン語（swe）、タジク語（tgk）、タミル語（tam）、テルグ語（tel）、タイ語（tha）、トルコ語（tur）、ウクライナ語（ukr）、ウルドゥー語（urd）、ウズベク語（uzb）、ベトナム語（vie）、ウェールズ語（cym）、ウォロフ語（wol）、ズールー語（zul）。

Eleven v3

Eleven v3は前世代の音声合成モデルで、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした音声を生成します。

Eleven v3では、新しいテキストtoダイアログAPIを利用できます。これにより、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした会話を生成できます。Eleven v3はテキスト読み上げAPIでも使用でき、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした音声を生成できます。

テキストtoダイアログAPIの詳細はこちらをご覧ください。

対応言語

Eleven v3モデルは、以下を含む70以上の言語に対応しています。

アフリカーンス語（afr）、アラビア語（ara）、アルメニア語（hye）、アッサム語（asm）、アゼルバイジャン語（aze）、ベラルーシ語（bel）、ベンガル語（ben）、ボスニア語（bos）、ブルガリア語（bul）、カタロニア語（cat）、セブアノ語（ceb）、チェワ語（nya）、クロアチア語（hrv）、チェコ語（ces）、デンマーク語（dan）、オランダ語（nld）、英語（eng）、エストニア語（est）、フィリピノ語（fil）、フィンランド語（fin）、フランス語（fra）、ガリシア語（glg）、ジョージア語（kat）、ドイツ語（deu）、ギリシャ語（ell）、グジャラート語（guj）、ハウサ語（hau）、ヘブライ語（heb）、ヒンディー語（hin）、ハンガリー語（hun）、アイスランド語（isl）、インドネシア語（ind）、アイルランド語（gle）、イタリア語（ita）、日本語（jpn）、ジャワ語（jav）、カンナダ語（kan）、カザフ語（kaz）、キルギス語（kir）、韓国語（kor）、ラトビア語（lav）、リンガラ語（lin）、リトアニア語（lit）、ルクセンブルク語（ltz）、マケドニア語（mkd）、マレー語（msa）、マラヤーラム語（mal）、中国語（標準語）（cmn）、マラーティー語（mar）、ネパール語（nep）、ノルウェー語（nor）、パシュトー語（pus）、ペルシア語（fas）、ポーランド語（pol）、ポルトガル語（por）、パンジャブ語（pan）、ルーマニア語（ron）、ロシア語（rus）、セルビア語（srp）、シンド語（snd）、スロバキア語（slk）、スロベニア語（slv）、ソマリ語（som）、スペイン語（spa）、スワヒリ語（swa）、スウェーデン語（swe）、タミル語（tam）、テルグ語（tel）、タイ語（tha）、トルコ語（tur）、ウクライナ語（ukr）、ウルドゥー語（urd）、ベトナム語（vie）、ウェールズ語（cym）。

Eleven v3 Conversational

Eleven v3 Conversationalは、リアルタイム音声合成向けの前世代モデルです。複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした音声を生成します。

Eleven v3 Conversationalでは、新しいテキストtoダイアログWebSocketを利用できます。これにより、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした会話を生成できます。

Eleven v3 Conversationalでは、新しいテキストtoダイアログWebSocketを利用できます。これにより、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした会話を生成できます。

テキストtoダイアログWebSocketの詳細はこちらをご覧ください。

対応言語

Eleven v3モデルは、以下を含む70以上の言語に対応しています。

アフリカーンス語（afr）、アラビア語（ara）、アルメニア語（hye）、アッサム語（asm）、アゼルバイジャン語（aze）、ベラルーシ語（bel）、ベンガル語（ben）、ボスニア語（bos）、ブルガリア語（bul）、カタロニア語（cat）、セブアノ語（ceb）、チェワ語（nya）、クロアチア語（hrv）、チェコ語（ces）、デンマーク語（dan）、オランダ語（nld）、英語（eng）、エストニア語（est）、フィリピノ語（fil）、フィンランド語（fin）、フランス語（fra）、ガリシア語（glg）、ジョージア語（kat）、ドイツ語（deu）、ギリシャ語（ell）、グジャラート語（guj）、ハウサ語（hau）、ヘブライ語（heb）、ヒンディー語（hin）、ハンガリー語（hun）、アイスランド語（isl）、インドネシア語（ind）、アイルランド語（gle）、イタリア語（ita）、日本語（jpn）、ジャワ語（jav）、カンナダ語（kan）、カザフ語（kaz）、キルギス語（kir）、韓国語（kor）、ラトビア語（lav）、リンガラ語（lin）、リトアニア語（lit）、ルクセンブルク語（ltz）、マケドニア語（mkd）、マレー語（msa）、マラヤーラム語（mal）、中国語（標準語）（cmn）、マラーティー語（mar）、ネパール語（nep）、ノルウェー語（nor）、パシュトー語（pus）、ペルシア語（fas）、ポーランド語（pol）、ポルトガル語（por）、パンジャブ語（pan）、ルーマニア語（ron）、ロシア語（rus）、セルビア語（srp）、シンド語（snd）、スロバキア語（slk）、スロベニア語（slv）、ソマリ語（som）、スペイン語（spa）、スワヒリ語（swa）、スウェーデン語（swe）、タミル語（tam）、テルグ語（tel）、タイ語（tha）、トルコ語（tur）、ウクライナ語（ukr）、ウルドゥー語（urd）、ベトナム語（vie）、ウェールズ語（cym）。

Multilingual v2

Eleven Multilingual v2は、感情を考慮する前世代の音声合成モデルです。複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした音声を生成します。

このモデルは、話者固有の特徴とアクセントを維持しながら、すべての対応言語で一貫した音声品質と個性を実現します。

このモデルは、高品質で感情表現豊かな音声が必要な次のシナリオで優れています。

• キャラクターボイスオーバー：感情表現の幅が広く、ゲームやアニメーションに最適です。
• プロフェッショナルコンテンツ：企業ビデオやeラーニング教材に適しています。
• 多言語プロジェクト：言語を切り替えても一貫した音声品質を維持します。
• 安定した品質：一貫して高品質なオーディオ出力を生成します。

Flashモデルよりも1文字あたりのレイテンシーとコストは高くなりますが、生き生きとした音声が重要なプロジェクトでは優れた品質を提供します。

Multilingual v2モデルは、29言語に対応しています。

英語（米国、英国、オーストラリア、カナダ）、日本語、中国語、ドイツ語、ヒンディー語、フランス語（フランス、カナダ）、韓国語、ポルトガル語（ブラジル、ポルトガル）、イタリア語、スペイン語（スペイン、メキシコ）、インドネシア語、オランダ語、トルコ語、フィリピン語、ポーランド語、スウェーデン語、ブルガリア語、ルーマニア語、アラビア語（サウジアラビア、アラブ首長国連邦）、チェコ語、ギリシャ語、フィンランド語、クロアチア語、マレー語、スロバキア語、デンマーク語、タミル語、ウクライナ語、ロシア語。

Flash v2.5

Eleven Flash v2.5は、リアルタイムアプリケーションとAgents Platform向けに設計された、最も高速な音声合成モデルです。32言語で、超低レイテンシー（約75ms†）の高品質な音声を提供します。

このモデルは速度と品質のバランスを取り、言語間で自然な出力と一貫した音声特性を維持しながら、インタラクティブなアプリケーションに最適です。

このモデルは、特に次の用途に適しています。

• Agents Platform：リアルタイム音声エージェントやチャットボットに最適です。
• インタラクティブアプリケーション：即時応答が必要なゲームやアプリケーションに最適です。
• 大規模処理：大量のテキスト読み上げ変換を効率的に行えます。

API生成の低価格と75msのレイテンシーにより、Flash v2.5は複数言語で高速かつ信頼性の高い音声合成を必要とする場合に、コスト効率の高い選択肢です。

Flash v2.5は、v2モデルのすべての言語に加え、以下を含む32言語に対応しています。

ハンガリー語、ノルウェー語、ベトナム語

考慮事項

モデル選択ガイド

要件やユースケースに最適なモデルについては、モデル選択ガイドをご覧ください。

文字数制限

1回のテキスト読み上げリクエストでサポートされる最大文字数は、モデルによって異なります。

Scribe v2

Scribe v2は、90以上の言語で正確な文字起こしを行うために設計された、最先端の音声認識モデルです。正確な単語レベルのタイムスタンプに加え、話者ダイアライゼーションや動的オーディオタグ付けなどの高度な機能を提供します。

このモデルは、正確なスピーチtoテキスト変換が必要なシナリオで優れた性能を発揮します。

• 文字起こしサービス：オーディオ／ビデオコンテンツをテキストに変換するのに最適
• 会議の記録：会話を記録・文書化するのに最適
• コンテンツ分析：オーディオコンテンツの処理・分析に適しています
• 多言語認識：90以上の言語で正確な文字起こしに対応

主な機能：

• 単語レベルのタイムスタンプを含む正確な文字起こし
• 複数話者のオーディオに対応する話者ダイアライゼーション
• 文脈を強化する動的オーディオタグ付け
• 90以上の言語をサポート
• エンティティ検出
• キータームプロンプト
• 文字起こしの編集

Scribe v2の詳細はこちらをご覧ください。

Scribe v2 Realtime

最速かつ最も正確なライブ音声認識モデルであるScribe v2 Realtimeは、超低レイテンシーの150msで、90以上の言語において最先端の精度を実現します。

このモデルは、会話型のユースケースで優れた性能を発揮します。

• ライブ会議の文字起こし：リアルタイム文字起こしに最適
• AIエージェント：ライブ会話に最適
• 多言語認識：自動言語認識により、90以上の言語で正確な文字起こしに対応

主な機能：

• 超低レイテンシー：約150ミリ秒で部分的な文字起こしを取得
• ストリーミング対応：オーディオをチャンクで送信しながら、リアルタイムで文字起こしを受信
• 複数のオーディオ形式：PCM（8kHz～48kHz）およびμ-lawエンコーディングに対応
• 音声アクティビティ検出（VAD）：無音検出に基づく自動音声セグメンテーション
• 手動コミット制御：文字起こしセグメントを確定するタイミングを完全に制御
• エンティティ検出
• 文字起こしの編集

Scribe v2 Realtimeの詳細はこちらをご覧ください。

Scribe v2 Medical

Scribe v2 Medicalは、医療および臨床オーディオに特化したバッチ音声認識モデルです。Scribe v2を微調整したモデルで、日常会話におけるScribe v2の精度を維持しながら、薬剤名、解剖学、病理学、臨床ディクテーションの認識を改善します。Scribe v2と同じスピーチtoテキストAPIを使用し、料金も同一です。model_idとしてscribe_v2_medicalを渡してください。

このモデルは、以下の用途に適しています。

• 臨床文書化：会話の途中で医療用語が出てくる環境音を含む診察や記録
• ディクテーション：薬剤、用量、所見が密に連続する音声
• 問診・連携通話：多くの場合電話で、患者が自身の症状を説明する通話
• コンプライアンスワークフロー：PHIカテゴリにはエンティティ検出と組み合わせて使用

主な機能：

• Scribe v2と同じリクエスト形式（keyterms、entity_detection、no_verbatim、ダイアライゼーション、タイムスタンプ）
• 薬剤名、解剖学用語、病理学用語の認識を改善
• Scribe v2と比べて日常会話の精度低下なし
• 90以上の言語をサポート
• 複数話者のオーディオに対応する話者ダイアライゼーション
• 動的オーディオタグ付け
• PHIカテゴリを含むエンティティ検出

Scribe v2 Medicalはバッチモデルです。ライブ文字起こしにはScribe v2 Realtimeを使用してください。

Scribe v2 MedicalはHIPAAの対象であり、エンタープライズのお客様にはBusiness Associate Agreement（BAA）およびZero Retention Mode（ZRM）をご利用いただけます。ZRMを有効にすると、オーディオ入力とテキスト出力は各リクエストの完了直後に削除されます。ElevenLabsは何も保持せず、アプリケーションは完全なAPIレスポンスを受け取り、独自の管理下で文字起こしを保持します。

スピーチtoテキストの詳細はこちらをご覧ください。

Elevenミュージック

Elevenミュージックは、スタジオ品質の音楽生成モデルです。自然言語プロンプトを使って、あらゆるスタイルの音楽を生成できます。

このモデルは、次のようなシナリオに最適です。

• ゲームサウンドトラック：ゲーム向けの没入感あるサウンドトラックを作成
• ポッドキャストの背景音楽：プロフェッショナルな音楽でポッドキャストを引き立てる
• マーケティング：広告動画にバックグラウンド音楽を追加

主な機能：

• ジャンル、スタイル、構成を完全にコントロール
• ボーカルありまたはインストゥルメンタルのみ
• 英語、スペイン語、ドイツ語、日本語などを含む多言語対応
• 個々のセクションまたは曲全体のサウンドと歌詞を編集

Elevenミュージックの詳細はこちらをご覧ください。

同時実行数と優先度

サブスクリプションプランによって、同時に処理できるリクエスト数と、キュー内でのリクエストの優先度が決まります。 スピーチtoテキストの同時実行数上限は引き上げられています。 同時実行数の上限に達すると、その後のリクエストは優先度の低いリクエストとともにキューで処理されます。 通常、これによって増えるレイテンシーは約50ms程度です。

レスポンスヘッダーには、同時実行数を監視するために使用できる current-concurrent-requests と maximum-concurrent-requests が含まれます。

1分あたりのAPIリクエスト数と同時実行リクエスト数

1分あたりのAPIリクエスト数と同時実行リクエスト数は、使用パターンによって異なる指標であることを理解しておくことが重要です。

1分あたりのAPIリクエスト数は、各リクエストにかかる時間やリクエストのバッチ処理方法に依存するため、同時実行リクエスト数とは異なる場合があります。

例1：間隔を空けたリクエスト 各リクエストの完了に1秒かかる毎分180リクエストを、0.33秒間隔で送信した場合、常に3件のリクエストが処理中となるため、同時実行リクエスト数の最大値と平均値はいずれも3になります。

例2：バッチリクエスト 一方、各リクエストの完了に3秒かかる毎分180リクエストをすべて一度に送信するような使用パターンでは、同時実行リクエスト数の最大値は180、平均値は9になります（1分の最初の3秒間は180リクエストが同時に存在し、残りの57秒間は0リクエストです）。

システムでは同時実行数を重視するため、1分あたりのリクエスト数よりも、各リクエストにかかる時間と送信タイミングのパターンの方が重要です。

エンドポイントへのリクエスト方法は、同時実行数上限に影響します。

• HTTPでは、各リクエストが個別に同時実行数上限へカウントされます。
• テキスト読み上げWebSocketでは、モデルがオーディオを生成している時間のみが同時実行数上限にカウントされます。つまり、ほとんどの時間では、開いているWebSocketは同時実行数上限にまったくカウントされません。
• テキストtoダイアログWebSocketの仕組みは異なります。開いている各接続は、接続が維持されている間、別のプールから1つのダイアログセッションを予約します。接続経由で生成されたオーディオは、通常の同時実行数上限にはカウントされません。1接続が1セッションとなるため理解しやすく、新しい同時実行方式に合わせてダイアログセッション上限が設定されています。詳しくは、テキストtoダイアログの同時実行数をご覧ください。

同時実行数上限について

プランに紐づく同時実行数上限は、同時に処理できる会話、電話、キャラクターボイスオーバーなどの最大数として解釈すべきではありません。 実際の数は、使用するAI音声やユースケースの特性など、複数の要因によって異なります。

一般的な目安として、同時実行数上限が5の場合、通常は約100件までの同時オーディオ配信に対応できます。

これは、オーディオの生成速度がTTSリクエストの処理時間に比べて速いためです。 以下の図は、同時実行リクエスト数を2に抑えながら、異なるユーザーとの4件の同時通話を処理する例です。

エンタープライズプランをご利用で、いずれかの時点でプランの同時実行数上限を超えた場合でも、利用可能な容量に応じてベストエフォートで、より低速ながらモデルリクエストが成功することがあります。

テキストtoダイアログの同時実行数

テキストtoダイアログのリクエストは、APIの呼び出し方法に応じて2種類の方法で計測されます。

• HTTPエンドポイント（ダイアログを作成およびダイアログをストリーミング）は、他のテキスト読み上げリクエストと同様に、オーディオ生成中はプランの通常の同時実行数上限にカウントされます。
• テキストtoダイアログWebSocketなどのWebSocketエンドポイントは、ダイアログセッションとして計測されます。オーディオを生成中かどうかにかかわらず、開いている接続は、接続が維持されている間、ダイアログセッションを占有します。

セッションベースの計測により、容量計画がシンプルになります。1接続が1セッションとなるため、使用量は生成アクティビティによって変動しません。オーディオ生成中だけでなく接続全体でセッションが占有されるため、この新しい同時実行方式に合わせてダイアログセッション上限が設定されています。

ワークスペースのダイアログセッションがすべて使用中のときに接続を開くと、新しい接続は too_many_concurrent_requests エラーで拒否されます。セッションを解放するには、不要になった接続を閉じてください。keep_alive メッセージを送信しない限り、接続は20秒間の非アクティブ状態の後に自動的に閉じられます。

ダイアログセッションを監視するには、ダッシュボードのサイドバー下部にある Developers を開き、Analytics タブを選択して、Usageビューの Concurrent requests 指標を確認します。ダイアログセッションは、他の同時実行リクエストとは別に、TTD Websocket Sessions という独自の系列としてレポートされます。

同時実行数上限のスケールテスト

スケールテストは、クライアント側のスケーリング問題を特定し、ユースケースに対して同時実行数上限が適切に設定されていることを確認するのに役立ちます。

実際の使用状況にできる限り近いエンドツーエンドのワークフローをテストすることを強く推奨します。対応可能なユーザー数をシミュレーションして測定することが、そのための推奨される手法です。次の点が重要です。

• 生のリクエストではなく、ユーザーをシミュレーションする
• リクエストを送信する前に、オーディオ再生、ユーザーの発話、文字起こしの完了を待つなど、一般的なユーザー行動をシミュレーションする
• 数分かけてユーザー数を徐々に増やす
• リクエストのタイミングとリクエストサイズにランダム性を加える
• レイテンシー指標とAPIから返されたエラーコードを収集する

たとえば、100件の同時会話をサポートするよう設計されたエージェントシステムをテストするには、それぞれが会話をシミュレーションする最大100人の個別「ユーザー」を作成します。会話は通常、約10秒間のユーザーの発話、約150文字に対するTTS API呼び出し、約10秒間のユーザーへのオーディオ再生というサイクルを繰り返します。したがって、各ユーザーは20秒ごとに、150文字のテキストに対するWebSocketのテキスト読み上げAPI呼び出しを行うパターンに従う必要があります。このとき、待機時間とリクエストする文字数に少量のランダム性を加えます。テストでは、100人に達するまで1秒ごとに1ユーザーを起動し、その後、全体の安定性をテストするために合計10分間実行します。

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