Gemini-TTS

התנסות ב-Gemini-TTS ב-Agent Studio התנסות ב-Colab הצגת ה-notebook ב-GitHub

‫Gemini-TTS הוא הגרסה העדכנית ביותר של טכנולוגיית Cloud TTS, שמאפשרת לא רק ליצור דיבור שנשמע טבעי, אלא גם לשלוט באופן מדויק באודיו שנוצר באמצעות הנחיות טקסט. באמצעות Gemini-TTS, אתם יכולים לסנתז דיבור של דובר אחד או של כמה דוברים, מקטעים קצרים ועד נרטיבים ארוכים, ולהכתיב במדויק את הסגנון, המבטא, הקצב, הטון ואפילו את הביטוי הרגשי – והכול באמצעות הנחיות בשפה טבעית.

מודלים זמינים

אלה המודלים שזמינים ב-Gemini-TTS:

‫Gemini 3.1 Flash TTS (גרסת טרום-השקה)

מזהה המודל gemini-3.1-flash-tts-preview
מותאם ל- יצירת אודיו ב-Cloud TTS עם זמן אחזור קצר, אפשרות שליטה, דובר אחד או כמה דוברים, לאפליקציות יומיומיות חסכוניות
אופני קלט ופלט
  • קלט: טקסט
  • פלט: אודיו
מגבלות על טוקנים
  • קלט: 8,192
  • פלט: 16,384
תמיכה במספר הדוברים דובר יחיד, דוברים מרובים (דיאלוג)
פורמטים נתמכים של פלט אודיו
  • Unary: ‏LINEAR16 (ברירת מחדל), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • סטרימינג: PCM (ברירת המחדל), ALAW, MULAW, OGG_OPUS
תמיכה באזורים אזורים זמינים
אפשרויות קוליות לעיון באפשרויות של Voice
אפשרויות קוליות לעיון באפשרויות של Voice חשוב לזכור שכל הקולות של Gemini 3.1 Flash TTS הם בגרסת טרום-השקה (Preview).
אפשרויות צריכה מידע על תשלום לפי שימוש רגיל
דוגמה 
model: "gemini-3.1-flash-tts-preview"
prompt: "You are having a casual conversation with a friend.
         Say the following in a friendly and amused way."
text: "[laughs] I did NOT expect that. [sigh] Can you believe it!"
speaker: "Callirrhoe"

Gemini 2.5 Flash TTS

מזהה המודל gemini-2.5-flash-tts
מותאם ל- יצירת אודיו ב-Cloud TTS עם זמן אחזור קצר, אפשרות שליטה, דובר אחד או כמה דוברים, לאפליקציות יומיומיות חסכוניות
אופני קלט ופלט
  • קלט: טקסט
  • פלט: אודיו
מגבלות על טוקנים
  • קלט: 8,192
  • פלט: 16,384
תמיכה במספר הדוברים דובר יחיד, מספר דוברים
פורמטים נתמכים של פלט אודיו
  • Unary: ‏LINEAR16 (ברירת מחדל), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • סטרימינג: PCM (ברירת המחדל), ALAW, MULAW, OGG_OPUS
תמיכה באזורים אזורים זמינים
אפשרויות קוליות לעיון באפשרויות של Voice
השפות הזמינות לרשימת השפות הזמינות
דוגמה 
model: "gemini-2.5-flash-tts"
prompt: "Say the following."
text: "[extremely fast] Availability and terms may vary.
       Check our website or your local store for complete
       details and restrictions."
speaker: "Kore"

‫Gemini 2.5 Flash Lite TTS (גרסת טרום-השקה)

מזהה המודל gemini-2.5-flash-lite-preview-tts
מותאם ל- יצירת אודיו ב-Cloud TTS עם זמן אחזור קצר, אפשרות שליטה ודובר יחיד, לאפליקציות יומיומיות חסכוניות. שימו לב שהמודל הזה נמצא בגרסת טרום-השקה (Preview).
אופני קלט ופלט
  • קלט: טקסט
  • פלט: אודיו
מגבלות על טוקנים
  • קלט: 8,192
  • פלט: 16,384
תמיכה במספר הדוברים רווק/ה
פורמטים נתמכים של פלט אודיו
  • Unary: ‏LINEAR16 (ברירת מחדל), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • סטרימינג: PCM (ברירת המחדל), ALAW, MULAW, OGG_OPUS
תמיכה באזורים אזורים זמינים
אפשרויות קוליות לעיון באפשרויות של Voice
השפות הזמינות לרשימת השפות הזמינות
דוגמה 
model: "gemini-2.5-flash-lite-preview-tts"
prompt: "Say the following in an elated way."
text: "Congratulations on the recent achievements!"
speaker: "Aoede"

‫Gemini 2.5 Pro TTS

מזהה המודל gemini-2.5-pro-tts
מותאם ל- שליטה גבוהה בתהליכי עבודה מובְנים כמו יצירת פודקאסטים, ספרי אודיו, תמיכת לקוחות ועוד
אופני קלט ופלט
  • קלט: טקסט
  • פלט: אודיו
מגבלות על טוקנים
  • קלט: 8,192
  • פלט: 16,384
תמיכה במספר הדוברים דובר יחיד, מספר דוברים
פורמטים נתמכים של פלט אודיו
  • Unary: ‏LINEAR16 (ברירת מחדל), ALAW, MULAW, MP3, OGG_OPUS, PCM
  • סטרימינג: PCM (ברירת המחדל), ALAW, MULAW, OGG_OPUS
תמיכה באזורים אזורים זמינים
אפשרויות קוליות לעיון באפשרויות של Voice
השפות הזמינות לרשימת השפות הזמינות
דוגמה 
model: "gemini-2.5-pro-tts"
prompt: "You are having a casual conversation with a friend.
         Say the following in a friendly and amused way."
text: "hahah I did NOT expect that. Can you believe it!"
speaker: "Callirrhoe"

אמצעי בקרה נוספים

אמצעי בקרה ויכולות נוספים:

  1. שיחה טבעית: אינטראקציות קוליות באיכות יוצאת דופן, עם הבעה ודפוסי קצב מתאימים יותר, מועברות בזמן אחזור נמוך מאוד כדי שתוכלו לשוחח בצורה חלקה.

  2. שליטה בסגנון: באמצעות הנחיות בשפה טבעית, אתם יכולים להתאים את אופן הדיבור בשיחה על ידי שינוי המבטא, טון הדיבור וההבעות, כולל לחישה.

  3. ביצועים דינמיים: המודלים האלה יכולים להפיח חיים בטקסט כדי להקריא בצורה אקספרסיבית שירה, מהדורות חדשות וסיפורים מרתקים. הם גם יכולים להביע רגשות ספציפיים ולדבר במבטאים שונים לפי בקשה.

  4. שליטה משופרת בקצב ובהגייה: שליטה במהירות הדיבור עוזרת להבטיח הגייה מדויקת יותר, כולל של מילים ספציפיות.

כדי לדעת איך לבחור את ה-API המתאים לשימוש בקולות האלה באפליקציה, קראו את המאמר בחירת ה-API המתאים.

אפשרויות קוליות

‫Gemini-TTS מציע מגוון רחב של אפשרויות קוליות שדומות ל-Chirp 3: HD Voices הקיים, ולכל אחת מהן יש מאפיינים ייחודיים:

שם מגדר הדגמה
Achernar נקבה
Achird זכר
Algenib זכר
Algieba זכר
Alnilam זכר
Aoede נקבה
Autonoe נקבה
Callirrhoe נקבה
כארון זכר
Despina נקבה
אנקלאדוס זכר
Erinome נקבה
Fenrir זכר
Gacrux נקבה
יאפטוס זכר
Kore נקבה
Laomedeia נקבה
Leda נקבה
Orus זכר
Pulcherrima נקבה
Puck זכר
Rasalgethi זכר
Sadachbia זכר
Sadaltager זכר
Schedar זכר
Sulafat נקבה
Umbriel זכר
Vindemiatrix נקבה
Zephyr נקבה
Zubenelgenubi זכר

השפות הזמינות

‫Gemini-TTS תומך בשפות הבאות:

שפה קוד BCP-47 מוכנות להשקה
ערבית (מצרים) ar-EG GA
בנגלית (בנגלדש) bn-BD GA
הולנדית (הולנד) nl-NL GA
אנגלית (הודו) en-IN GA
אנגלית (ארצות הברית) en-US GA
צרפתית (צרפת) fr-FR GA
גרמנית (גרמניה) de-DE GA
הינדית (הודו) hi-IN GA
אינדונזית (אינדונזיה) id-ID GA
איטלקית (איטליה) it-IT GA
יפנית (יפן) ja-JP GA
קוריאנית (דרום קוריאה) ko-KR GA
מראטהית (הודו) mr-IN GA
פולנית (פולין) pl-PL GA
פורטוגזית (ברזיל) pt-BR GA
רומנית (רומניה) ro-RO GA
רוסית (רוסיה) ru-RU GA
ספרדית (ספרד) es-ES GA
טמילית (הודו) ta-IN GA
טלוגו (הודו) te-IN GA
תאית (תאילנד) th-TH GA
טורקית (טורקיה) tr-TR GA
אוקראינית (אוקראינה) uk-UA GA
וייטנאמית (וייטנאם) vi-VN GA
אפריקאנס (דרום אפריקה) af-ZA תצוגה מקדימה
אלבנית (אלבניה) sq-AL תצוגה מקדימה
אמהרית (אתיופיה) am-ET תצוגה מקדימה
ערבית (כל העולם) ar-001 תצוגה מקדימה
ארמנית (ארמניה) hy-AM תצוגה מקדימה
אזרית (אזרבייג'ן) az-AZ תצוגה מקדימה
בסקית (ספרד) eu-ES תצוגה מקדימה
בלארוסית (בלארוס) be-BY תצוגה מקדימה
בולגרית (בולגריה) bg-BG תצוגה מקדימה
בורמזית (מיאנמר) my-MM תצוגה מקדימה
קטלאנית (ספרד) ca-ES תצוגה מקדימה
סבואנו (הפיליפינים) ceb-PH תצוגה מקדימה
סינית, מנדרינית (סין) cmn-CN תצוגה מקדימה
סינית, מנדרינית (טייוואן) cmn-tw תצוגה מקדימה
קרואטית (קרואטיה) hr-HR תצוגה מקדימה
צ'כית (צ'כיה) cs-CZ תצוגה מקדימה
דנית (דנמרק) da-DK תצוגה מקדימה
אנגלית (אוסטרליה) en-AU תצוגה מקדימה
אנגלית (בריטניה) en-GB תצוגה מקדימה
אסטונית (אסטוניה) et-EE תצוגה מקדימה
פיליפינית (פיליפינים) fil-PH תצוגה מקדימה
פינית (פינלנד) fi-FI תצוגה מקדימה
צרפתית (קנדה) fr-CA תצוגה מקדימה
גליציאנית (ספרד) gl-ES תצוגה מקדימה
גאורגית (גאורגיה) ka-GE תצוגה מקדימה
יוונית (יוון) el-GR תצוגה מקדימה
גוג'ראטית (הודו) gu-IN תצוגה מקדימה
קריאולית האיטית (האיטי) ht-HT תצוגה מקדימה
עברית (ישראל) he-IL תצוגה מקדימה
הונגרית (הונגריה) hu-HU תצוגה מקדימה
איסלנדית (איסלנד) is-IS תצוגה מקדימה
ג'אווה (ג'אווה) jv-JV תצוגה מקדימה
קאנדה (הודו) kn-IN תצוגה מקדימה
קונקאני (הודו) kok-IN תצוגה מקדימה
לאו (לאוס) lo-LA תצוגה מקדימה
לטינית (קריית הוותיקן) la-VA תצוגה מקדימה
לטבית (לטביה) lv-LV תצוגה מקדימה
ליטאית (ליטא) lt-LT תצוגה מקדימה
לוקסמבורגית (לוקסמבורג) lb-LU תצוגה מקדימה
מקדונית (מקדוניה הצפונית) mk-MK תצוגה מקדימה
מאיתילי (הודו) mai-IN תצוגה מקדימה
מלגשית (מדגסקר) mg-MG תצוגה מקדימה
מלאית (מלזיה) ms-MY תצוגה מקדימה
מליאלאם (הודו) ml-IN תצוגה מקדימה
מונגולית (מונגוליה) mn-MN תצוגה מקדימה
נפאלית (נפאל) ne-NP תצוגה מקדימה
נורווגית, בוקמול (נורווגיה) nb-NO תצוגה מקדימה
נורווגית, נינורסק (נורווגיה) nn-NO תצוגה מקדימה
אודיה (הודו) or-IN תצוגה מקדימה
פאשטו (אפגניסטן) ps-AF תצוגה מקדימה
פרסית (אירן) fa-IR תצוגה מקדימה
פורטוגזית (פורטוגל) pt-PT תצוגה מקדימה
פנג'אבי (הודו) pa-IN תצוגה מקדימה
סרבית (סרביה) sr-RS תצוגה מקדימה
סינדהית (הודו) sd-IN תצוגה מקדימה
סינהלית (סרי לנקה) si-LK תצוגה מקדימה
סלובקית (סלובקיה) sk-SK תצוגה מקדימה
סלובנית (סלובניה) sl-SI תצוגה מקדימה
ספרדית (אמריקה הלטינית) es-419 תצוגה מקדימה
ספרדית (מקסיקו) es-MX תצוגה מקדימה
סווהילי (קניה) sw-KE תצוגה מקדימה
שוודית (שוודיה) sv-SE תצוגה מקדימה
אורדו (פקיסטן) ur-PK תצוגה מקדימה

אזורים זמינים

‫Gemini-TTS זמין בכמה אזורים, דרך Cloud Text-to-Speech API או Vertex AI API.

עיבוד נתוני למידת המכונה במודלים האלה מתבצע באזור הספציפי או במספר האזורים שבהם נשלחה הבקשה. מידע נוסף זמין במאמר מיקום אחסון הנתונים.

ב-Cloud Text-to-Speech API יש תמיכה באזורים הבאים:

אזור מדינה או סמכות שיפוט מודלים זמינים
global גלובלי (לא DRZ) gemini-3.1-flash-tts-preview
gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
us ארצות הברית gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
eu האיחוד האירופי gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
northamerica-northeast1 קנדה gemini-2.5-flash-tts
gemini-2.5-flash-lite-preview-tts

אפשר לגשת לאזורים האלה באמצעות נקודות הקצה הבאות ל-API: <REGION>-texttospeech.googleapis.com. שימו לב שלאזור global אין קידומת: texttospeech.googleapis.com.

ב-Vertex AI API, יש תמיכה באזורים הבאים:

אזור מדינה או סמכות שיפוט מודלים זמינים
global גלובלי (לא DRZ) gemini-3.1-flash-tts-preview
gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
europe-central2 האיחוד האירופי gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
europe-north1 האיחוד האירופי gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
europe-southwest1 האיחוד האירופי gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
europe-west1 האיחוד האירופי gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
europe-west4 האיחוד האירופי gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
northamerica-northeast1 קנדה gemini-2.5-flash-tts
gemini-2.5-flash-lite-preview-tts
us-central1 ארצות הברית gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
us-east1 ארצות הברית gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
us-east4 ארצות הברית gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
us-east5 ארצות הברית gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
us-south1 ארצות הברית gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
us-west1 ארצות הברית gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts
us-west4 ארצות הברית gemini-2.5-flash-tts
gemini-2.5-pro-tts
gemini-2.5-flash-lite-preview-tts

אפשר לגשת לאזורים האלה באמצעות נקודות הקצה הבאות ל-API: <REGION>-aiplatform.googleapis.com. שימו לב שלאזור global אין קידומת: aiplatform.googleapis.com.

בחירת ה-API המתאים

איך משתמשים במודלים של Gemini-TTS כדי לסנתז דיבור של דובר יחיד או של כמה דוברים באמצעות Cloud Text-to-Speech API או Vertex AI API.

‫Gemini-TTS זמין דרך שני ממשקי API כדי לפשט את תהליך השילוב ללקוחות. ‫Cloud Text-to-Speech API ו-Vertex AI API, עם נקודות קצה (endpoints) של REST וערכות SDK בכמה שפות תכנות.

ריכזנו כאן כמה הנחיות שיעזרו לכם לבחור את ה-API המתאים.

אם התנאים הבאים מתקיימים, בוחרים ב-Cloud Text-to-Speech API:

  1. אם אתם משתמשים ב-Chirp 3 HD או בקולות אחרים, אתם יכולים להמשיך להשתמש באותו Cloud Text-to-Speech API עם עדכונים מצטברים מינימליים.
  2. אם אתם צריכים סוגים ספציפיים של קידוד פלט, אתם יכולים לציין קידוד אודיו ב-Cloud Text-to-Speech API. ב-Vertex AI API, הפלט הוא נתוני אודיו של PCM 16bit 24k, ואין לו כותרות WAV. אם רוצים להמיר לפורמט אודיו אחר, צריך לבצע את ההמרה בצד הלקוח.
  3. אם אתם חייבים להעביר טקסט בסטרימינג בכמה מקטעים, Cloud Text-to-Speech API תומך באינטראקציה של כמה בקשות וכמה תשובות. לעומת זאת, Vertex AI API תומך בבקשה אחת ובכמה תשובות.
  4. אם רוצים להחיל נורמליזציה של טקסט כברירת מחדל. האפשרות הזו שימושית במיוחד לתמלילים שכוללים תאריכים וערכים כספיים.

בחרו ב-Vertex AI API אם:

  1. אם אתם כבר משתמשים ב-Gemini-TTS מ-AI Studio, אתם יכולים לעבור ל-Vertex AI בצורה חלקה כדי ליהנות מהמדרגיות ומהתאימות של Google Cloud.
  2. אם אתם משתמשים ב-Vertex AI API למודלים אחרים, המבנה המאוחד של ה-API מאפשר לכם להתחיל להשתמש ב-Gemini-TTS בקלות רבה יותר. אתם רק צריכים לציין את שם המודל ואת אפשרויות הקול.

שימוש ב-Cloud Text-to-Speech API

אם אתם צריכים אפשרויות שהן לא ברירת המחדל, אתם יכולים לציין פורמטים של אודיו ותדירויות דגימה בשדה "audioConfig".

תיאור הגבלה סוג
שדה לטקסט קטן מ-4,000 בייטים או שווה להם. קלט
שדה ההנחיה קטן מ-4,000 בייטים או שווה להם. קלט
שדות טקסט והנחיות קטן מ-8,000 בייטים או שווה ל-8,000 בייטים. קלט
משך הזמן של פלט האודיו בערך 655 שניות. אם טקסט הקלט יוצר אודיו שארוך מ-655 שניות, האודיו נחתך. תשובה

לפני שמתחילים

כדי להשתמש ב-Cloud Text-to-Speech, צריך להפעיל את ה-API במסוףGoogle Cloud לפי השלבים הבאים:

  1. להפעיל את Cloud Text-to-Speech בפרויקט.
  2. מוודאים שהחיוב מופעל ב-Cloud Text-to-Speech.
  3. מגדירים אימות לסביבת הפיתוח.
  4. מקצים את ההרשאה aiplatform.endpoints.predict למשתמש המאומת. אפשר לתת את ההרשאה הזו באמצעות התפקיד roles/aiplatform.user.
  5. בוחרים את נקודת הקצה הנכונה ל-API בהתאם לאזורים הזמינים.

הגדרת הפרויקט ב- Google Cloud

  1. כניסה למסוף Google Cloud

  2. כניסה לדף לבחירת הפרויקט

    אפשר לבחור פרויקט קיים או ליצור פרויקט חדש. למידע נוסף על יצירת פרויקט, עיינו במאמרי העזרה שלGoogle Cloud .

  3. אם יוצרים פרויקט חדש, מופיעה הודעה שבה אתם מתבקשים לקשר חשבון לחיוב. אם אתם משתמשים בפרויקט קיים, ודאו שהפעלתם את החיוב.

    איך מוודאים שהחיוב מופעל בפרויקט

  4. אחרי שבוחרים פרויקט ומקשרים אותו לחשבון לחיוב, אפשר להפעיל את Cloud Text-to-Speech API. בסרגל Search products and resources שבחלק העליון של הדף, מקלידים speech. בוחרים את Cloud Text-to-Speech API מרשימת התוצאות.

  5. כדי לנסות את Cloud Text-to-Speech בלי לקשר אותו לפרויקט, בוחרים באפשרות Try this API. כדי להפעיל את Cloud Text-to-Speech API לשימוש בפרויקט, לוחצים על Enable.

  6. מגדירים אימות לסביבת הפיתוח. להוראות, ראו הגדרת אימות ל-Cloud Text-to-Speech.

הגדרת נקודת קצה ל-API לאזור המועדף

אתם יכולים לבחור נקודת קצה (endpoint) על סמך האזורים הזמינים.

Python

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
TTS_LOCATION = os.getenv("GOOGLE_CLOUD_REGION")

API_ENDPOINT = (
    f"{TTS_LOCATION}-texttospeech.googleapis.com"
    if TTS_LOCATION != "global"
    else "texttospeech.googleapis.com"
)
client = texttospeech.TextToSpeechClient(
    client_options=ClientOptions(api_endpoint=API_ENDPOINT)
)

CURL

GLOBAL_API_ENDPOINT=https://texttospeech.googleapis.com
REGIONAL_API_ENDPOINT=https://YOUR_REGION-texttospeech.googleapis.com

ביצוע סינתזה סינכרונית של דובר יחיד

Python

# google-cloud-texttospeech minimum version 2.29.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize(prompt: str, text: str, output_filepath: str = "output.mp3"):
    """Synthesizes speech from the input text and saves it to an MP3 file.

    Args:
        prompt: Styling instructions on how to synthesize the content in
          the text field.
        text: The text to synthesize.
        output_filepath: The path to save the generated audio file.
          Defaults to "output.mp3".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text, prompt=prompt)

    # Select the voice you want to use.
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        name="Charon",  # Example voice, adjust as needed
        model_name="gemini-3.1-flash-tts-preview"
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    # Perform the text-to-speech request on the text input with the selected
    # voice parameters and audio file type.
    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    # The response's audio_content is binary.
    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following in a curious way.",
    "text": "OK, so... tell me about this [uhm] AI thing."
  },
  "voice": {
    "languageCode": "en-us",
    "name": "Kore",
    "model_name": "gemini-3.1-flash-tts-preview"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

ביצוע סינתזה של סטרימינג עם דובר יחיד

המרת טקסט לדיבור בסטרימינג מתאימה לאפליקציות בזמן אמת, שבהן תגובה מהירה היא קריטית לחוויית המשתמש. בחיבור בסטרימינג, ה-API מחזיר אודיו בחלקים קטנים כשהם הופכים לזמינים.

כגורם שמבצע את הקריאה ל-API, חשוב לוודא שאתם צורכים את קטעי האודיו ומעבירים אותם ללקוחות שלכם כשהם מגיעים (לדוגמה, באמצעות socketio לאפליקציות אינטרנט).

‫Cloud Text-to-Speech API תומך בסטרימינג מסוג multiple request multiple response. אפשר לשלוח את חלקי הקלט ל-API באופן אסינכרוני, כמו שמוצג ב-request_generator, אבל ה-API מתחיל את ההמרה רק כשהלקוח שולח את Half-Close כאות לכך שהוא לא ישלח יותר נתונים ל-API.

צריך להגדיר את השדה prompt בחלק הראשון של הקלט, כי המערכת מתעלמת ממנו בחלקים הבאים.

Python

# google-cloud-texttospeech minimum version 2.29.0 is required.

import datetime
import os
import numpy as np
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize(prompt: str, text_chunks: list[str], model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        prompt: Styling instructions on how to synthesize the content in
          the text field.
        text_chunks: Text chunks to synthesize. Note that The synthesis will 
          start when the client initiates half-close. 
        model: gemini tts model name. gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales. 
    """
    client = texttospeech.TextToSpeechClient()

    config_request = texttospeech.StreamingSynthesizeRequest(
        streaming_config=texttospeech.StreamingSynthesizeConfig(
            voice=texttospeech.VoiceSelectionParams(
                name=voice,
                language_code=locale,
                model_name=model
            )
        )
    )

    # Example request generator. A function like this can be linked to an LLM
    # text generator and the text can be passed to the TTS API asynchronously.
    def request_generator():
      yield config_request

      for i, text in enumerate(text_chunks):
        yield texttospeech.StreamingSynthesizeRequest(
            input=texttospeech.StreamingSynthesisInput(
              text=text, 
              # Prompt is only supported in the first input chunk.
              prompt=prompt if i == 0 else None,
            )
        )

    request_start_time = datetime.datetime.now()
    streaming_responses = client.streaming_synthesize(request_generator())

    is_first_chunk_received = False
    final_audio_data = np.array([])
    num_chunks_received = 0
    for response in streaming_responses:
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")

        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        # accumulating audio. In a web-server scenario, you would want to 
        # "emit" audio to the frontend as soon as it arrives.
        #
        # For example using flask socketio, you could do the following
        # from flask_socketio import SocketIO, emit
        # emit("audio", response.audio_content)
        # socketio.sleep(0)
        audio_data = np.frombuffer(response.audio_content, dtype=np.int16)
        final_audio_data = np.concatenate((final_audio_data, audio_data))

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time
    audio_duration = len(final_audio_data) / 24_000  # default sampling rate.

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")
    print(f"Audio duration: {audio_duration} seconds")

    return final_audio_data

ביצוע סינתזה סינכרונית של כמה דוברים עם קלט טקסט חופשי

תיאור אילוצים ומגבלות סוג
שדה לטקסט עד 4,000 בייטים קלט
שדה ההנחיה עד 4,000 בייטים קלט
שדות טקסט והנחיות קטן מ-8,000 בייטים או שווה ל-8,000 בייטים קלט
כינויים של הדוברים תווים אלפאנומריים ללא רווחים קלט
משך הזמן של פלט האודיו בערך 655 שניות. אם טקסט הקלט יוצר אודיו שארוך מ-655 שניות, האודיו נחתך. תשובה

Python

# google-cloud-texttospeech minimum version 2.31.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize_multispeaker_freeform(
    prompt: str,
    text: str,
    output_filepath: str = "output_non_turn_based.wav",
):
    """Synthesizes speech from non-turn-based input and saves it to a WAV file.

    Args:
        prompt: Styling instructions on how to synthesize the content in the
          text field.
        text: The text to synthesize, containing speaker aliases to indicate
          different speakers. Example: "Sam: Hi Bob!\nBob: Hi Sam!"
        output_filepath: The path to save the generated audio file. Defaults to
          "output_non_turn_based.wav".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text, prompt=prompt)

    multi_speaker_voice_config = texttospeech.MultiSpeakerVoiceConfig(
        speaker_voice_configs=[
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker1",
                speaker_id="Kore",
            ),
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker2",
                speaker_id="Charon",
            ),
        ]
    )

    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        model_name="gemini-3.1-flash-tts-preview",
        multi_speaker_voice_config=multi_speaker_voice_config,
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16,
        sample_rate_hertz=24000,
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts and gemini-2.5-pro-tts
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
# google-cloud-texttospeech minimum version 2.31.0 is required.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following as a conversation between friends.",
    "text": "Sam: Hi Bob, how are you?\\nBob: I am doing well, and you?"
  },
  "voice": {
    "languageCode": "en-us",
    "modelName": "gemini-3.1-flash-tts-preview",
    "multiSpeakerVoiceConfig": {
      "speakerVoiceConfigs": [
        {
          "speakerAlias": "Sam",
          "speakerId": "Kore"
        },
        {
          "speakerAlias": "Bob",
          "speakerId": "Charon"
        }
      ]
    }
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16",
    "sampleRateHertz": 24000
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

ביצוע סינתזה סינכרונית של כמה דוברים עם קלט טקסט מובנה

התכונה "מספר דוברים עם קלט טקסט מובנה" מאפשרת להמיר טקסט לדיבור בצורה חכמה וטבעית. לדוגמה, קלט מהסוג הזה שימושי לכתובות ולתאריכים. אם תזינו טקסט חופשי, הוא יוקרא בדיוק כמו שהוא כתוב.

תיאור אילוצים ומגבלות סוג
השדה MultiSpeakerMarkUp עד 4,000 בייטים קלט
שדה ההנחיה עד 4,000 בייטים קלט
שדות MultiSpeakerMarkUp והנחיה קטן מ-8,000 בייטים או שווה ל-8,000 בייטים קלט
כינויים של הדוברים תווים אלפאנומריים ללא רווחים קלט
משך הזמן של פלט האודיו בערך 655 שניות. אם טקסט הקלט יוצר אודיו שארוך מ-655 שניות, האודיו נחתך. תשובה

Python

# google-cloud-texttospeech minimum version 2.31.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize_multispeaker_structured(
    prompt: str,
    turns: list[texttospeech.MultiSpeakerMarkup.Turn],
    output_filepath: str = "output_turn_based.wav",
):
    """Synthesizes speech from turn-based input and saves it to a WAV file.

    Args:
        prompt: Styling instructions on how to synthesize the content in the
          text field.
        turns: A list of texttospeech.MultiSpeakerMarkup.Turn objects representing
          the dialogue turns.
        output_filepath: The path to save the generated audio file. Defaults to
          "output_turn_based.wav".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(
        multi_speaker_markup=texttospeech.MultiSpeakerMarkup(turns=turns),
        prompt=prompt,
    )

    multi_speaker_voice_config = texttospeech.MultiSpeakerVoiceConfig(
        speaker_voice_configs=[
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker1",
                speaker_id="Kore",
            ),
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker2",
                speaker_id="Charon",
            ),
        ]
    )

    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        model_name="gemini-3.1-flash-tts-preview",
        multi_speaker_voice_config=multi_speaker_voice_config,
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16,
        sample_rate_hertz=24000,
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
# google-cloud-texttospeech minimum version 2.31.0 is required.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following as a conversation between friends.",
    "multiSpeakerMarkup": {
      "turns": [
        {
          "speaker": "Sam",
          "text": "Hi Bob, how are you?"
        },
        {
          "speaker": "Bob",
          "text": "I am doing well, and you?"
        }
      ]
    }
  },
  "voice": {
    "languageCode": "en-us",
    "modelName": "gemini-3.1-flash-tts-preview",
    "multiSpeakerVoiceConfig": {
      "speakerVoiceConfigs": [
        {
          "speakerAlias": "Sam",
          "speakerId": "Kore"
        },
        {
          "speakerAlias": "Bob",
          "speakerId": "Charon"
        }
      ]
    }
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16",
    "sampleRateHertz": 24000
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

שימוש ב-Vertex AI API

איך משתמשים במודלים של Gemini-TTS כדי ליצור דיבור של דובר יחיד או של כמה דוברים באמצעות Vertex AI API.

ב-Cloud Text-to-Speech API, המשתמש יכול לספק שדות של טקסט והנחיה בנפרד. ב-Vertex AI API, זהו שדה contents יחיד, שבו מצוין הקלט בפורמט "{prompt}: {text}", לדוגמה: "תגיד את המשפט הבא בצורה סקרנית: אוקיי, אז… ספר לי על ה-AI הזה".

תיאור הגבלה סוג
שדה התוכן קטן מ-8,000 בייטים או שווה ל-8,000 בייטים. קלט
משך הזמן של פלט האודיו בערך 655 שניות. אם טקסט הקלט יוצר אודיו שארוך מ-655 שניות, האודיו נחתך. תשובה

לפני שמתחילים

לפני שמתחילים, צריך לבצע את שלבי ההתקנה של Vertex AI API. כדי להשתמש באפשרויות של מיקום אחסון הנתונים, צריך להגדיר את LOCATION לפי האזורים הזמינים.

ביצוע סינתזה סינכרונית של דובר יחיד

דוגמאות הקוד הבאות ממחישות איך לבצע סינתזה סינכרונית של דובר יחיד.

Python

from google import genai
from google.genai import types
import wave
import os

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

response = client.models.generate_content(
  model="gemini-3.1-flash-tts-preview",
  contents="Say the following in a curious way: OK, so... tell me about this [uhm] AI thing.",
  config=types.GenerateContentConfig(
      speech_config=types.SpeechConfig(
        language_code="en-in",
        voice_config=types.VoiceConfig(
            prebuilt_voice_config=types.PrebuiltVoiceConfig(
              voice_name='Kore',
            )
        )
      ),
  )
)

data = response.candidates[0].content.parts[0].inline_data.data

file_name='output_speech.wav'
wave_file(file_name, data) # Saves the file to current directory

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "contents": {
    "role": "user",
    "parts": { "text": "Say the following in a curious way: OK, so... tell me about this [uhm] AI thing." }
  },
  "generation_config": {
    "speech_config": {
        "language_code": "en-in",
        "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "kore"
            }
        }
    }
  }
  }' \
  https://aiplatform.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-3.1-flash-tts-preview:generateContent \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 -d | ffmpeg -f s16le -ar 24k -ac 1 -i - output_speech.wav

ביצוע סינתזה של סטרימינג עם דובר יחיד

ב-Vertex AI API יש תמיכה בסטרימינג חד-כיווני, כלומר הלקוח שולח בקשה אחת ומקבל סטרימינג של תשובות.

דוגמת הקוד הזו ממחישה איך לבצע סינתזה של סטרימינג עם דובר יחיד.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

def synthesize(text: str, model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        text: Text to synthesize.
        model: gemini tts model name. Available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales.
    """
    client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

    generate_content_config=types.GenerateContentConfig(
        speech_config=types.SpeechConfig(
          language_code=locale,
          voice_config=types.VoiceConfig(
              prebuilt_voice_config=types.PrebuiltVoiceConfig(
                voice_name=voice,
              )
          )
        ),
    )

    request_start_time = datetime.datetime.now()
    is_first_chunk_received = False
    final_audio_data = bytes()
    num_chunks_received = 0

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=text,
        config=generate_content_config,
    ):
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")
        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        if (
            chunk.candidates is None
            or not chunk.candidates
            or chunk.candidates[0].content is None
            or not chunk.candidates[0].content.parts
        ):
            continue
        part = chunk.candidates[0].content.parts[0]
        if part.inline_data and part.inline_data.data:
          # accumulating audio. In a web-server scenario, you would want to
          # "emit" audio to the frontend as soon as it arrives.
          #
          # For example using flask socketio, you could do the following
          # from flask_socketio import SocketIO, emit
          # emit("audio", chunk.candidates[0].content.parts[0].inline_data.data)
          # socketio.sleep(0)
          final_audio_data += chunk.candidates[0].content.parts[0].inline_data.data

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")

    return final_audio_data

audio_data = synthesize(
    "Say the following in a curious way: Radio Bakery is a New York City gem, celebrated for its exceptional and creative baked goods. The pistachio croissant is often described as a delight with perfect sweetness. The rhubarb custard croissant is a lauded masterpiece of flaky pastry and tart filling. The brown butter corn cake stands out with its crisp edges and rich flavor. Despite the bustle, the staff consistently receives praise for being friendly and helpful.",
    "gemini-3.1-flash-tts-preview",
    "Kore",
    "en-in")
file_name='output_speech.wav'
wave_file(file_name, audio_data)

Audio("output_speech.wav")

ביצוע סינתזה סינכרונית של כמה דוברים

דוגמת הקוד הזו ממחישה איך לבצע סינתזה סינכרונית של כמה דוברים.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

prompt = """TTS the following conversation between Joe and Jane:
        Joe: How's it going today Jane?
        Jane: Not too bad, how about you?"""

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

response = client.models.generate_content(
  model="gemini-3.1-flash-tts-preview",
  contents=prompt,
  config=types.GenerateContentConfig(
      speech_config=types.SpeechConfig(
        language_code="en-in",
        multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
              types.SpeakerVoiceConfig(
                  speaker='Joe',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                    )
                  )
              ),
              types.SpeakerVoiceConfig(
                  speaker='Jane',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                    )
                  )
              ),
            ]
        )
      ),
  )
)

data = response.candidates[0].content.parts[0].inline_data.data

file_name='output_speech.wav'
wave_file(file_name, data) # Saves the file to current directory

Audio("output_speech.wav")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "contents": {
    "role": "user",
    "parts": { "text": "Say the following as a conversation between friends: Sam: Hi Bob, how are you?\\nBob: I am doing well, and you?" }
  },
  "generation_config": {
    "speech_config": {
      "language_code": "en-in",
      "multi_speaker_voice_config": {
        "speaker_voice_configs": [{
          "speaker": "Sam",
          "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "Aoede"
            }
          }
        },{
          "speaker": "Bob",
          "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "Algieba"
            }
          }
        }]
      }
    },
  }
  }' \
  https://aiplatform.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-3.1-flash-tts-preview:generateContent \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 -d | ffmpeg -f s16le -ar 24k -ac 1 -i - output_speech.wav

ביצוע סינתזה של סטרימינג עם כמה דוברים

ב-Vertex AI API יש תמיכה בסטרימינג חד-כיווני, כלומר הלקוח שולח בקשה אחת ומקבל סטרימינג של תשובות.

דוגמת הקוד הזו ממחישה איך לבצע סינתזה של סטרימינג עם כמה דוברים.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

prompt = """TTS the following conversation between Joe and Jane:
        Joe: How's it going today Jane?
        Jane: Not too bad! Honestly, I'm just blown away by this new Gemini Text-to-Speech model.
        Joe: Right?! This is a total game changer! And do you know what I just discovered?
        Jane: What?
        Joe: You can use the multi-speaker configuration to create a conversation, just like us!
        Jane: Just like us!"""

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

def synthesize(text: str, model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        text: Text to synthesize. Note that The synthesis will start when the
          client initiates half-close.
        model: gemini tts model name. Available models are: gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales.
    """
    client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

    generate_content_config=types.GenerateContentConfig(
        speech_config=types.SpeechConfig(
        language_code="en-in",
        multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
              types.SpeakerVoiceConfig(
                  speaker='Joe',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                    )
                  )
              ),
              types.SpeakerVoiceConfig(
                  speaker='Jane',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                    )
                  )
              ),
            ]
        )
      ),
    )

    request_start_time = datetime.datetime.now()
    is_first_chunk_received = False
    final_audio_data = bytes()
    num_chunks_received = 0

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=text,
        config=generate_content_config,
    ):
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")
        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        if (
            chunk.candidates is None
            or not chunk.candidates
            or chunk.candidates[0].content is None
            or not chunk.candidates[0].content.parts
        ):
            continue
        part = chunk.candidates[0].content.parts[0]
        if part.inline_data and part.inline_data.data:
          # accumulating audio. In a web-server scenario, you would want to
          # "emit" audio to the frontend as soon as it arrives.
          #
          # For example using flask socketio, you could do the following
          # from flask_socketio import SocketIO, emit
          # emit("audio", chunk.candidates[0].content.parts[0].inline_data.data)
          # socketio.sleep(0)
          final_audio_data += chunk.candidates[0].content.parts[0].inline_data.data

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")

    return final_audio_data

audio_data = synthesize(
    prompt,
    "gemini-3.1-flash-tts-preview",
    "Kore",
    "en-in")
file_name='output_speech.wav'
wave_file(file_name, audio_data)

Audio("output_speech.wav")

המרת טקסט לדיבור ב-Media Studio

אתם יכולים להשתמש ב-Media Studio במסוף Google Google Cloud כדי להתנסות במודלים של המרת טקסט לדיבור (TTS). זהו ממשק משתמש שמאפשר ליצור במהירות אודיו מסונתז, להאזין לו ולהתנסות בהוראות ובפרמטרים שונים של סגנון.

  1. במסוף Google Google Cloud , נכנסים לדף Agent Studio > Media Studio.

    Media Studio

  2. בתפריט הנפתח של המדיה, בוחרים באפשרות דיבור.

  3. בשדה הטקסט, מזינים את הטקסט שרוצים להמיר לדיבור.

  4. בחלונית Settings, קובעים את ההגדרות הבאות:

    1. דגם: בוחרים את המודל של Cloud TTS‏ (TTS) שבו רוצים להשתמש, למשל Gemini 2.5 Pro TTS. מידע נוסף על המודלים הזמינים מופיע במאמר מודלים של Cloud TTS.
    2. הוראות לגבי הסגנון: אופציונלי: מזינים הנחיית טקסט שמתארת את סגנון הדיבור, הטון וההבעה הרגשית שנבחרו. כך אתם יכולים להנחות את המודל איך להקריא את הטקסט, מעבר להגדרות ברירת המחדל. לדוגמה: "קריינות בטון רגוע ומקצועי לסרט תיעודי".
    3. שפה: בוחרים את השפה והאזור של טקסט הקלט. המודל יוצר דיבור בשפה ובמבטא שנבחרו. לדוגמה, אנגלית (ארצות הברית).
    4. קול: בוחרים קול מוגדר מראש לקריינות. הרשימה מכילה את הקולות הזמינים למודל ולשפה שנבחרו, כמו Acherner (נקבה).

  5. אופציונלי: מרחיבים את הקטע "אפשרויות מתקדמות" כדי לקבוע הגדרות אודיו טכניות:

    1. קידוד אודיו: בוחרים את הקידוד של קובץ האודיו שנוצר. ‫LINEAR16 הוא פורמט ללא אובדן מידע וללא דחיסה, שמתאים לעיבוד אודיו באיכות גבוהה. אפשר להשתמש ב-MULAW גם לפלט אודיו דחוס.
    2. תדירות דגימת האודיו: בוחרים את תדירות הדגימה בהרץ (Hz). ההגדרה הזו קובעת את איכות האודיו. ערכים גבוהים יותר, כמו 44,100Hz, מייצגים אודיו באיכות גבוהה יותר, שוות ערך לאיכות של תקליטור.
    3. מהירות: כדי לשנות את קצב הדיבור, מזיזים את פס ההזזה או מזינים ערך. ערכים קטנים מ-1 מאטים את הדיבור, וערכים גדולים מ-1 מאיצים אותו. ערך ברירת המחדל הוא 1.
    4. הגברת עוצמת הקול (dB): שינוי עוצמת הקול של האודיו בדציבלים (dB). ערכים חיוביים מגבירים את עוצמת הקול, וערכים שליליים מנמיכים אותה. ערך ברירת המחדל הוא 0.

  6. כדי ליצור את האודיו, לוחצים על סמל השליחה שמשמאל לתיבת הטקסט.

  7. האודיו שנוצר מופיע בנגן המדיה. לוחצים על כפתור ההפעלה כדי להאזין לפלט. אתם יכולים להמשיך לשנות את ההגדרות וליצור גרסאות חדשות לפי הצורך.

טיפים לכתיבת פרומפטים

כדי ליצור אודיו מעניין שנשמע טבעי מטקסט, צריך להבין את הניואנסים של השפה המדוברת ולתרגם אותם לתסריט. הטיפים הבאים יעזרו לכם ליצור תסריטים שנשמעים אותנטיים ומתאימים לסגנון שבחרתם.

שלושת המנופים לשליטה בדיבור

כדי לקבל את התוצאות הכי צפויות ומדויקות, חשוב לוודא ששלושת הרכיבים הבאים תואמים לתוצאה הרצויה.

הנחיית סגנון הגורם העיקרי שמשפיע על הטון הרגשי הכללי ועל אופן ההגשה. ההנחיה מגדירה את ההקשר של כל קטע הדיבור.

  • לדוגמה: You are an AI assistant speaking in a friendly and helpful tone.

  • לדוגמה: Narrate this in the calm, authoritative tone of a nature documentary narrator.

תוכן הטקסט המשמעות הסמנטית של המילים שאתם ממירים לדיבור. ביטוי מעורר רגשות שתואם מבחינה רגשית להנחיה לגבי הסגנון יניב תוצאות הרבה יותר מהימנות מאשר טקסט ניטרלי.

  • טוב: הנחיה לטון מפוחד פועלת בצורה הטובה ביותר עם טקסט כמו I think someone is in the house.

  • פחות יעיל: הנחיה לטון מפוחד עם טקסט כמו The meeting is at 4 PM. תניב תוצאות לא ברורות.

תגי עיצוב (גרסת טרום-השקה (Preview)) תגים בסוגריים מרובעים כמו [sigh] מתאימים בעיקר להוספת פעולה או שינוי סגנון ספציפיים ומקומיים, ולא להגדרת הטון הכללי. הם פועלים בשילוב עם הנחיית הסגנון ותוכן הטקסט.

מדריך לתגי עיצוב

מהמחקר שלנו עולה שתגי עיצוב בסוגריים מרובעים פועלים באחד משלושה מצבים נפרדים. כדי להשתמש בתג בצורה יעילה, חשוב להבין את המצב שלו.

מצב 1: צלילים שהם לא דיבור

התג מוחלף בקול נשמע שהוא לא דיבור (למשל, אנחה, צחוק). התג עצמו לא מוקרא. הן מצוינות להוספת היסוסים ותגובות מציאותיות, כמו של בני אדם.

תג התנהגות אמינות הדרכה
[sigh] הוספת צליל של אנחה. גבוהה ההנחיה משפיעה על האיכות הרגשית של האנחה.
[laughing] הוספת צחוק. גבוהה כדי לקבל את התוצאות הכי טובות, כדאי להשתמש בהנחיה ספציפית. לדוגמה, הנחיה כללית יכולה להניב צחוק של הלם, ואילו ההנחיה "תגיב בצחוק משועשע" יוצרת צחוק של שעשוע.
[uhm] הוספת צליל של היסוס. גבוהה התכונה הזו שימושית ליצירת תחושה טבעית יותר של שיחה.

מצב 2: שינוי סגנון

תגי העיצוב לא מוקראים, אבל הם משנים את אופן ההקראה של הדיבור שאחריהם. ההיקף ומשך הזמן של השינוי יכולים להשתנות.

תג התנהגות אמינות הדרכה
[sarcasm] מוסיף טון סרקסטי לביטוי הבא. גבוהה התג הזה הוא משתנה רב-עוצמה. הוא מדגים איך מושגים מופשטים יכולים להנחות בהצלחה את התוצרים של המודל.
[robotic] הדיבור שנשמע אחרי זה נשמע רובוטי. גבוהה ההשפעה יכולה להתפרס על פני ביטוי שלם. כדי לקבל את התוצאות הכי טובות, עדיין מומלץ להשתמש בהנחיה תומכת לסגנון (למשל, "תגיד את זה בצורה רובוטית").
[shouting] מגבירה את עוצמת הקול של הדיבור הבא. גבוהה האפקט הכי יעיל כשמשלבים אותו עם הנחיה תואמת לסגנון (למשל, "תצעק את החלק הבא") וטקסט שמרמז על צעקה.
[whispering] החלשת עוצמת הקול של הדיבור הבא. גבוהה התוצאות הטובות ביותר מתקבלות כשההנחיה לגבי הסגנון היא גם מפורשת (למשל, "עכשיו תלחש את החלק הזה בשקט ככל האפשר").
[extremely fast] הגברת המהירות של הדיבור הבא. גבוהה האפשרות הזו מתאימה לכתבי ויתור או לדיאלוגים מהירים. נדרשת תמיכה מינימלית בהנחיות.

מצב 3: תגי עיצוב מנוקדים (שמות תואר)

תג התגיות עצמו מוקרא כמילה, וגם משפיע על הטון של המשפט כולו. ההתנהגות הזו רלוונטית בדרך כלל לשמות תואר רגשיים.

אזהרה: מכיוון שהתג עצמו מוקרא, סביר להניח שהמצב הזה הוא תופעת לוואי לא רצויה ברוב תרחישי השימוש. במקום זאת, עדיף להשתמש בהנחיית הסגנון כדי להגדיר את הטונים הרגשיים האלה.

תג התנהגות אמינות הדרכה
[scared] המילה "מפחיד" נאמרת, והמשפט מקבל טון מפחיד. גבוהה הביצועים תלויים מאוד בתוכן הטקסט. המשפט "הרגע שמעתי חלון נשבר" מניב תוצאה מפוחדת באמת. ביטוי ניטרלי יוביל לתוצאה "מפחידה" אבל פחות אותנטית.
[curious] המילה "סקרן" נאמרת, והמשפט מקבל טון סקרני. גבוהה כדאי להשתמש בביטוי שמעורר סקרנות כדי לתמוך בכוונה של התג.
[bored] המילה "משועמם" נאמרת, והמשפט נאמר בטון משועמם ומונוטוני. גבוהה כדי להשיג את האפקט הטוב ביותר, כדאי להשתמש בטקסט שגרתי או שחוזר על עצמו.

מצב 4: קצב והפסקות

התגים האלה מוסיפים שתיקה לאודיו שנוצר, ומאפשרים לכם לשלוט בקצב, בתזמון ובמהירות. גם סימני פיסוק רגילים (פסיקים, נקודות, נקודה ופסיק) יוצרים הפסקות טבעיות, אבל התגים האלה מאפשרים שליטה מפורשת יותר.

תג התנהגות אמינות הדרכה
[short pause] הוספת הפסקה קצרה, בדומה לפסיק (כ-250 אלפיות השנייה). גבוהה משתמשים בהם כדי להפריד בין משפטים או פריטים ברשימה כדי לשפר את הבהירות.
[medium pause] הוספת הפסקה רגילה, כמו הפסקה בין משפטים (כ-500 אלפיות השנייה). גבוהה יעיל להפרדה בין משפטים או רעיונות שונים.
[long pause] מוסיפה הפסקה משמעותית לאפקט דרמטי (כ-1,000 אלפיות השנייה או יותר). גבוהה השתמשו בהם כדי ליצור תזמון דרמטי. לדוגמה: "התשובה היא... [long pause] ...לא." אל תשתמשו בהן יותר מדי, כי זה עלול להישמע לא טבעי.

אסטרטגיות מרכזיות לקבלת תוצאות מהימנות

  • התאמה בין שלושת המנופים: כדי להשיג יכולת חיזוי מקסימלית, ודאו שההנחיה לסגנון, תוכן הטקסט וכל תגי העיצוב עקביים מבחינה סמנטית ופועלים להשגת אותה מטרה.

  • השתמשו בטקסט עשיר ברגשות: אל תסתמכו רק על הנחיות ותגים. תנו למודל טקסט עשיר ותיאורי. זה חשוב במיוחד כשמדובר ברגשות מורכבים כמו סרקזם, פחד או התרגשות.

  • כתבו הנחיות ספציפיות ומפורטות: ככל שהנחיית הסגנון תהיה ספציפית יותר, כך התוצאה תהיה מהימנה יותר. "תגיב בצחוק משועשע" עדיף על [laughing]. "דבר כמו קריין חדשות ברדיו משנות ה-40" עדיף על "דבר בצורה מיושנת".

  • בודקים ומאמתים תגים חדשים: לא תמיד אפשר לחזות את ההתנהגות של תג חדש או תג שלא נבדק. יכול להיות שתג שאתם חושבים שהוא משנה סגנון יוקרא בקול. לפני שאתם פורסים את התג או ההנחיה החדשים בסביבת הייצור, חשוב לבדוק את השילוב ביניהם כדי לוודא שהם פועלים כמו שצריך.

הגדרות של טיימר לדיווח על מצב מסוכן

יש בדיקות בטיחות שאי אפשר להשבית, אבל אתם יכולים לשנות את ערכי הסף של קטגוריות פגיעה מסוימות כדי לשפר את הבטיחות ולצמצם את הסיכוי לשימוש לרעה. כדי להפעיל את האפשרות הזו, צריך להגדיר מסנני בטיחות ב-AdvancedVoiceOptions.

יש 4 קטגוריות של פגיעה שאפשר להגדיר ברמות שונות של סף. אפשר להגדיר קטגוריה אחת או יותר כדי לחסום תוכן פוגעני.

השדה relax_safety_filters הקודם הוצא משימוש.

בהתאם למסנני הבטיחות שהגדרתם, הפלט עשוי להכיל קוד בטיחות שדומה לזה: "Cloud Text-to-Speech could not generate audio because the input text or prompt violates Vertex AI's usage guidelines.‎ אם לדעתך זו טעות, אפשר לשלוח משוב. קודי תמיכה: 62263041"

הקוד שמופיע בפלט תואם לקטגוריה ספציפית של תוכן מזיק.

בטבלה הבאה מוצג המיפוי של קודי התמיכה לקטגוריות הבטיחות:

קוד תמיכה קטגוריית בטיחות תיאור
54702341 לא צוין קטגוריה לא מוגדרת.
62263041 תוכן מסוכן תוכן שעלול להיות מסוכן.
57734940 הטרדה תוכן שקשור להטרדה.
90789179
 תוכן מיני בוטה תוכן מיני או תוכן שכולל רמיזות מיניות.
78610348 דברי שטנה תוכן שמכיל דברי שטנה.

הדוגמאות האלה מראות איך להתאים אישית את הגדרות הבטיחות ב-Cloud Text-to-Speech API. כדי להשתמש ב-Vertex AI API, עיינו בדוגמאות ל-Vertex AI API.

Python

# google-cloud-texttospeech minimum version 2.32.0 is required.
request = texttospeech.SynthesizeSpeechRequest(
    input=synthesis_input,
    voice=voice,
    audio_config=audio_config,
    advanced_voice_options=texttospeech.AdvancedVoiceOptions(
      safety_settings=texttospeech.AdvancedVoiceOptions.SafetySettings(
          settings=[texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_HARASSMENT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          )]
      )
    ),
)
# Perform the text-to-speech request on the text input with the selected
# voice parameters and audio file type.
response = client.synthesize_speech(request=request)

CURL

PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following in a curious way.",
    "text": "I am saying something that would otherwise be blocked by Gemini TTS."
  },
  "voice": {
    "languageCode": "en-us",
    "name": "Kore",
    "modelName": "gemini-3.1-flash-tts-preview"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  },
  "advancedVoiceOptions": {
    "safetySettings": {
      "settings": {
        "category": "HARM_CATEGORY_HATE_SPEECH",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_HARASSMENT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
    }
  },
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit