Get started with Live API

API Live обеспечивает голосовое и видеовзаимодействие с Gemini в режиме реального времени с минимальной задержкой. Он обрабатывает непрерывные потоки аудио, видео и текста, обеспечивая мгновенные, реалистичные голосовые ответы, создавая для пользователей естественный диалог.

Обзор живого API

Live API предлагает комплексный набор функций, таких как обнаружение голосовой активности , использование инструментов и вызов функций , управление сеансами (для управления длительными разговорами) и эфемерные токены (для безопасной аутентификации на стороне клиента).

На этой странице вы найдете примеры и базовые образцы кода, которые помогут вам приступить к работе.

Попробуйте Live API в Google AI Studio

Примеры приложений

Ознакомьтесь со следующими примерами приложений, которые иллюстрируют, как использовать Live API для сквозных сценариев использования:

Партнерские интеграции

Если вы предпочитаете более простой процесс разработки, вы можете использовать Daily , LiveKit или Voximplant . Это сторонние партнёрские платформы, которые уже интегрировали API Gemini Live через протокол WebRTC для упрощения разработки аудио- и видеоприложений в реальном времени.

Прежде чем начать строить

Прежде чем приступить к разработке с использованием Live API, необходимо принять два важных решения: выбрать модель и выбрать подход к реализации.

Выберите архитектуру генерации звука

Если вы создаете сценарий использования на основе звука, ваш выбор модели определяет архитектуру генерации звука, используемую для создания аудиоответа:

  • Собственный звук : этот вариант обеспечивает максимально естественное и реалистичное звучание речи и улучшенную многоязычность. Он также включает расширенные функции, такие как аффективный (с учётом эмоций) диалог , проактивный звук (когда модель может игнорировать или реагировать на определённые входные сигналы) и «мышление» . Собственный звук поддерживается следующими собственными звуковыми моделями :
    • gemini-2.5-flash-native-audio-preview-09-2025
  • Полукаскадное аудио : этот вариант использует каскадную архитектуру модели (входной аудиосигнал и вывод текста в речь). Он обеспечивает более высокую производительность и надежность в производственных средах, особенно при использовании инструментов . Полукаскадное аудио поддерживается следующими моделями:
    • gemini-live-2.5-flash-preview
    • gemini-2.0-flash-live-001

Выберите подход к реализации

При интеграции с Live API вам необходимо выбрать один из следующих подходов к реализации:

  • Сервер-сервер : ваш бэкенд подключается к Live API через WebSockets . Обычно ваш клиент отправляет потоковые данные (аудио, видео, текст) на ваш сервер, который затем пересылает их Live API.
  • Клиент-сервер : ваш код frontend подключается напрямую к Live API с помощью WebSockets для потоковой передачи данных, минуя ваш backend.

Начать

В этом примере считывается WAV-файл , отправляется в правильном формате и сохраняются полученные данные как WAV-файл.

Вы можете отправлять аудио, преобразовав его в формат 16-бит PCM, 16 кГц, моно, а также принимать аудио, выбрав AUDIO в качестве модальности ответа. Выходной сигнал использует частоту дискретизации 24 кГц.

Питон 

# Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
# Install helpers for converting files: pip install librosa soundfile
import asyncio
import io
from pathlib import Path
import wave
from google import genai
from google.genai import types
import soundfile as sf
import librosa

client = genai.Client()

# New native audio model:
model = "gemini-2.5-flash-native-audio-preview-09-2025"

config = {
  "response_modalities": ["AUDIO"],
  "system_instruction": "You are a helpful assistant and answer in a friendly tone.",
}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:

        buffer = io.BytesIO()
        y, sr = librosa.load("sample.wav", sr=16000)
        sf.write(buffer, y, sr, format='RAW', subtype='PCM_16')
        buffer.seek(0)
        audio_bytes = buffer.read()

        # If already in correct format, you can use this:
        # audio_bytes = Path("sample.pcm").read_bytes()

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

        wf = wave.open("audio.wav", "wb")
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(24000)  # Output is 24kHz

        async for response in session.receive():
            if response.data is not None:
                wf.writeframes(response.data)

            # Un-comment this code to print audio data info
            # if response.server_content.model_turn is not None:
            #      print(response.server_content.model_turn.parts[0].inline_data.mime_type)

        wf.close()

if __name__ == "__main__":
    asyncio.run(main())

JavaScript 

// Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
import { GoogleGenAI, Modality } from '@google/genai';
import * as fs from "node:fs";
import pkg from 'wavefile';  // npm install wavefile
const { WaveFile } = pkg;

const ai = new GoogleGenAI({});
// WARNING: Do not use API keys in client-side (browser based) applications
// Consider using Ephemeral Tokens instead
// More information at: https://ai.google.dev/gemini-api/docs/ephemeral-tokens

// New native audio model:
const model = "gemini-2.5-flash-native-audio-preview-09-2025"

const config = {
  responseModalities: [Modality.AUDIO],
  systemInstruction: "You are a helpful assistant and answer in a friendly tone."
};

async function live() {
    const responseQueue = [];

    async function waitMessage() {
        let done = false;
        let message = undefined;
        while (!done) {
            message = responseQueue.shift();
            if (message) {
                done = true;
            } else {
                await new Promise((resolve) => setTimeout(resolve, 100));
            }
        }
        return message;
    }

    async function handleTurn() {
        const turns = [];
        let done = false;
        while (!done) {
            const message = await waitMessage();
            turns.push(message);
            if (message.serverContent && message.serverContent.turnComplete) {
                done = true;
            }
        }
        return turns;
    }

    const session = await ai.live.connect({
        model: model,
        callbacks: {
            onopen: function () {
                console.debug('Opened');
            },
            onmessage: function (message) {
                responseQueue.push(message);
            },
            onerror: function (e) {
                console.debug('Error:', e.message);
            },
            onclose: function (e) {
                console.debug('Close:', e.reason);
            },
        },
        config: config,
    });

    // Send Audio Chunk
    const fileBuffer = fs.readFileSync("sample.wav");

    // Ensure audio conforms to API requirements (16-bit PCM, 16kHz, mono)
    const wav = new WaveFile();
    wav.fromBuffer(fileBuffer);
    wav.toSampleRate(16000);
    wav.toBitDepth("16");
    const base64Audio = wav.toBase64();

    // If already in correct format, you can use this:
    // const fileBuffer = fs.readFileSync("sample.pcm");
    // const base64Audio = Buffer.from(fileBuffer).toString('base64');

    session.sendRealtimeInput(
        {
            audio: {
                data: base64Audio,
                mimeType: "audio/pcm;rate=16000"
            }
        }

    );

    const turns = await handleTurn();

    // Combine audio data strings and save as wave file
    const combinedAudio = turns.reduce((acc, turn) => {
        if (turn.data) {
            const buffer = Buffer.from(turn.data, 'base64');
            const intArray = new Int16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Int16Array.BYTES_PER_ELEMENT);
            return acc.concat(Array.from(intArray));
        }
        return acc;
    }, []);

    const audioBuffer = new Int16Array(combinedAudio);

    const wf = new WaveFile();
    wf.fromScratch(1, 24000, '16', audioBuffer);  // output is 24kHz
    fs.writeFileSync('audio.wav', wf.toBuffer());

    session.close();
}

async function main() {
    await live().catch((e) => console.error('got error', e));
}

main();

Что дальше?