Gemini 3.5 Transcribe

Gemini 3.5 Transcribe est le modèle de Google permettant de convertir la voix en texte dans plusieurs langues. Il est disponible via Agent Platform. Basé sur les capacités de compréhension audio de Gemini, il fournit une transcription précise à faible latence avec détection de la langue basée sur les énoncés, identification du locuteur, codes temporels au niveau du mot, transcription intelligente et pondération vocale du vocabulaire personnalisé.

Gemini 3.5 Transcribe est le principal outil de transcription audio, qui comble l'écart entre les modèles multimodaux à raisonnement approfondi et les workflows de reconnaissance vocale hautement optimisés.

Pour commencer, consultez le notebook d'introduction à Gemini 3.5 Transcribe.

Il accepte deux méthodes de fonctionnement principales :

• Transcription en streaming (en direct) : diffuse l'audio et reçoit les résultats de la transcription de manière incrémentielle, en temps réel, à l'aide du modèle gemini-3.5-transcribe-live.
• Transcription synchrone : transcrit des fichiers audio complets préenregistrés en une seule requête à l'aide du modèle gemini-3.5-transcribe.

Compatibilité des fonctionnalités et limites

Gemini 3.5 Transcribe est compatible avec les fonctionnalités suivantes sur ses deux points de terminaison :

Transcription de la diffusion en direct

La BidiGenerateContent (Live) API reste ouverte pendant que vous diffusez de petits fragments audio vers le modèle et recevez les résultats de la transcription de manière incrémentielle, à mesure qu'ils deviennent disponibles. Cette fonctionnalité est utilisée pour le sous-titrage ou la transcription en temps quasi réel de l'entrée du micro.

Pour essayer la transcription en streaming sans écrire de code, ouvrez gemini-3.5-transcribe-live sur la page de l'API Gemini Live d'Agent Studio, puis enregistrez ou importez un fichier audio et regardez la transcription s'afficher en temps réel.

Essayer Gemini 3.5 Transcribe dans Agent Studio

Pour transcrire du contenu audio en streaming, créez un LiveConnectConfig et définissez response_modalities sur ["TEXT"] avec votre configuration input_audio_transcription.

import asyncio
from google import genai
from google.genai import types

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

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    input_audio_transcription=types.AudioTranscriptionConfig(
        language_codes=["it-IT", "en-US"],
    ),
)

async def streaming_main(audio_file, config):
    # Connect to the Live API session
    async with client.aio.live.connect(model="gemini-3.5-transcribe-live", config=config) as session:
        # In a complete implementation, you would chunk the audio and send via:
        # await session.send_realtime_input(audio=types.Blob(data=data, mime_type="audio/pcm;rate=16000"))
        # await session.send_realtime_input(audio_stream_end=True)

        async for message in session.receive():
            if message.server_content:
                server_content = message.server_content

                # Track the active interim segment
                interim = server_content.interim_input_transcription
                if interim and interim.text:
                    print(f"Interim: {interim.text}")

                # Save final transcript and clear the interim
                final = server_content.input_transcription
                if final and final.text:
                    print(f"Final: {final.text}")

Transcription synchrone

Vous pouvez utiliser la méthode generate_content standard pour transcrire des fichiers audio complets qui ont déjà été enregistrés. Configurez les paramètres en créant un AudioTranscriptionConfig dans GenerateContentConfig.

Codes temporels au niveau du mot

La définition de word_timestamp=True renvoie le code temporel au niveau du mot. La liste audio_transcription.words de la réponse contient chaque mot reconnu, ainsi que ses valeurs start_offset et end_offset.

from google import genai
from google.genai import types

# Initialize the client for Vertex AI / Agent Platform
client = genai.Client(enterprise=True, project=PROJECT_ID, location=LOCATION)

with open("input.wav", "rb") as f:
    audio_bytes = f.read()

response = client.models.generate_content(
    model="gemini-3.5-transcribe",
    contents=[
        types.Part.from_bytes(
            data=audio_bytes,
            mime_type="audio/wav",
        ),
    ],
    config=types.GenerateContentConfig(
        audio_transcription_config=types.AudioTranscriptionConfig(
            word_timestamp=True,
        ),
    ),
)

parts = getattr(response, "parts", []) or []
if parts and (audio_tx := getattr(parts[0], "audio_transcription", None)):
    for w in getattr(audio_tx, "words", []) or []:
        print(f"[{w.start_offset} - {w.end_offset}] {w.word}")

if text := "".join(p.text for p in parts if getattr(p, "text", None)):
    print(f"**{text}**")

Identification de l'intervenant et vocabulaire personnalisé

En définissant diarization=True, vous demandez au modèle d'identifier et d'étiqueter chaque locuteur. Vous pouvez également fournir un champ custom_vocabulary avec une liste d'expressions qui incitent Gemini 3.5 Transcribe à reconnaître des termes spécifiques. Le modèle suit généralement les instructions de vocabulaire personnalisé de manière plus fiable lorsqu'une langue est également spécifiée à l'aide de language_codes.

response = client.models.generate_content(
    model="gemini-3.5-transcribe",
    contents=[
        types.Part.from_uri(
            file_uri="gs://cloud-samples-data/generative-ai/audio/coffee_order.wav",
            mime_type="audio/wav",
        ),
    ],
    config=types.GenerateContentConfig(
        audio_transcription_config=types.AudioTranscriptionConfig(
            diarization=True,
            language_codes=["en-US"],
            custom_vocabulary=["oatmilk", "oz"],
        ),
    ),
)

parts = getattr(response, "parts", []) or []
for p in parts:
    audio_tx = getattr(p, "audio_transcription", None)
    speaker = getattr(audio_tx, "speaker_label", "UNKNOWN") if audio_tx else "UNKNOWN"
    text = getattr(p, "text", "") or (getattr(audio_tx, "text", "") if audio_tx else "")

    if text:
        print(f"**{speaker}**: {text}")

Modes de transcription

Gemini 3.5 Transcribe accepte deux modes de transcription via le paramètre mode dans AudioTranscriptionConfig :

• VERBATIM (par défaut) : renvoie une transcription exacte mot à mot de tout ce qui est dit, en conservant les mots de remplissage bruts ("euh", "hum", "genre", "tu vois"), les répétitions, les pauses et les faux départs.
• SMART (Transcription intelligente) : optimise la transcription pour la lecture en appliquant un post-traitement intelligent :
  • Suppression des disfluences : supprime les mots de remplissage, les bégaiements et les faux départs.
  • Autocorrections intégrées : résout directement les corrections vocales (par exemple, "On se voit mardi, non, mercredi à deux heures" devient "On se voit mercredi à 14h").
  • Mise en forme structurée automatique : structure automatiquement les pensées exprimées à l'oral en paragraphes, listes numérotées, listes à puces, dates, devises et nombres mis en forme.
  • Correction grammaticale : applique une ponctuation, une casse et un flux naturels.

Transcription synchrone avec le mode SMART

response = client.models.generate_content(
    model="gemini-3.5-transcribe",
    contents=[
        types.Part.from_bytes(
            data=audio_bytes,
            mime_type="audio/wav",
        ),
    ],
    config=types.GenerateContentConfig(
        audio_transcription_config=types.AudioTranscriptionConfig(
            mode="SMART",
        ),
    ),
)

Transcription instantanée avec le mode SMART et la détection manuelle des points de terminaison

Lorsque vous utilisez le mode SMART avec la transcription de streaming en direct (gemini-3.5-transcribe-live), vous devez utiliser la détection manuelle des points de terminaison (détection manuelle de l'activité vocale) au lieu de la détection automatique de l'activité vocale. Étant donné que le mode SMART applique un post-traitement au niveau de l'énoncé (par exemple, en résolvant les corrections automatiques intégrées et en structurant les listes ou les paragraphes), la VAD automatique peut diviser prématurément la pensée d'un utilisateur lors de pauses naturelles.

Pour configurer la détection manuelle des points de terminaison, désactivez automatic_activity_detection dans RealtimeInputConfig et marquez explicitement le début et la fin de la prise de parole de l'utilisateur à l'aide de activity_start et activity_end :

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    realtime_input_config=types.RealtimeInputConfig(
        automatic_activity_detection=types.AutomaticActivityDetection(
            disabled=True,
        ),
    ),
    input_audio_transcription=types.AudioTranscriptionConfig(
        mode="SMART",
    ),
)

async with client.aio.live.connect(
    model="gemini-3.5-transcribe-live", config=config
) as session:
    # Signal start of speech turn
    await session.send_realtime_input(activity_start=types.ActivityStart())

    # Stream audio chunks...
    await session.send_realtime_input(
        audio=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000")
    )

    # Signal end of speech turn so SMART mode can process the complete utterance
    await session.send_realtime_input(activity_end=types.ActivityEnd())

Langues acceptées

Les langues et codes de langue BCP-47 suivants sont compatibles avec Gemini 3.5 Transcribe :

Disponibilité en fonction des régions

Gemini 3.5 Transcribe est disponible dans les emplacements Cloud de Confiance by S3NS suivants :

Bonnes pratiques

• Fournissez un son clair : assurez-vous que les enregistrements audio permettent de bien distinguer les voix et évitez les coupures importantes.
• Fournissez des indications de langue lorsqu'elles sont connues : si vous connaissez la langue audio à l'avance, spécifiez language_codes pour maximiser la précision.
• Ciblez le vocabulaire personnalisé : incluez uniquement des termes de domaine, des noms de marque ou des noms propres distincts dans custom_vocabulary, plutôt que des mots courants.
• Utiliser la détection manuelle des fins de phrase avec le mode SMART dans la transcription en direct : désactivez la détection automatique de l'activité vocale (automatic_activity_detection) et envoyez explicitement les signaux activity_start et activity_end pour que le modèle puisse appliquer la suppression des disfluences, les corrections automatiques et la mise en forme sur l'ensemble des énoncés.

Essayer dans Agent Studio Tarifs