Live API की मदद से, Gemini के साथ कम समय में रीयल-टाइम में बोलकर और वीडियो के ज़रिए बातचीत की जा सकती है. यह ऑडियो, वीडियो या टेक्स्ट की लगातार स्ट्रीम को प्रोसेस करता है, ताकि इंसानों की तरह तुरंत जवाब दिया जा सके. इससे आपके उपयोगकर्ताओं को बातचीत करने का एक स्वाभाविक अनुभव मिलता है.
Live API में कई सुविधाएं मिलती हैं. जैसे, आवाज़ की गतिविधि का पता लगाना, टूल का इस्तेमाल करना और फ़ंक्शन कॉल करना, सेशन मैनेजमेंट (लंबे समय तक चलने वाली बातचीत को मैनेज करने के लिए), और अस्थायी टोकन (क्लाइंट-साइड पर सुरक्षित तरीके से पुष्टि करने के लिए).
इस पेज पर, उदाहरणों और बुनियादी कोड के सैंपल की मदद से, आपको इस सुविधा के बारे में जानकारी मिलती है.
Google AI Studio में Live API आज़माएं
उदाहरण के तौर पर ऐप्लिकेशन
यहां दिए गए उदाहरण ऐप्लिकेशन देखें. इनसे पता चलता है कि लाइव एपीआई का इस्तेमाल, शुरू से लेकर आखिर तक कैसे किया जाता है:
- AI Studio पर लाइव ऑडियो स्टार्टर ऐप्लिकेशन. इसमें JavaScript लाइब्रेरी का इस्तेमाल करके, Live API से कनेक्ट किया जाता है. साथ ही, माइक्रोफ़ोन और स्पीकर के ज़रिए दोनों दिशाओं में ऑडियो स्ट्रीम किया जाता है.
- Pyaudio का इस्तेमाल करके, Live API से कनेक्ट होने वाला Live API Python कुकबुक.
पार्टनर इंटिग्रेशन
अगर आपको डेवलपमेंट की आसान प्रोसेस चाहिए, तो Daily, LiveKit या Voximplant का इस्तेमाल करें. ये तीसरे पक्ष के पार्टनर प्लैटफ़ॉर्म हैं. इन्होंने WebRTC प्रोटोकॉल पर Gemini Live API को पहले ही इंटिग्रेट कर लिया है. इससे, रीयल-टाइम में ऑडियो और वीडियो ऐप्लिकेशन को आसानी से डेवलप किया जा सकता है.
इससे पहले कि आप
Live API का इस्तेमाल करके, लाइव चैट की सुविधा बनाने से पहले, आपको दो अहम फ़ैसले लेने होंगे: मॉडल चुनना और लागू करने का तरीका चुनना.
ऑडियो जनरेट करने के लिए कोई आर्किटेक्चर चुनना
अगर आपको ऑडियो पर आधारित कोई मॉडल बनाना है, तो आपके चुने गए मॉडल से यह तय होता है कि ऑडियो जनरेट करने के लिए किस आर्किटेक्चर का इस्तेमाल किया जाएगा. इस आर्किटेक्चर का इस्तेमाल, ऑडियो जनरेट करने के लिए किया जाता है:
- नेटिव ऑडियो:
इस विकल्प से, सबसे ज़्यादा नैचुरल और असली लगने वाली आवाज़ मिलती है. साथ ही, यह
कई भाषाओं में बेहतर तरीके से काम करता है.
इससे भावनाओं को समझने वाली बातचीत, प्रोऐक्टिव ऑडियो (इसमें मॉडल यह तय कर सकता है कि कुछ इनपुट को अनदेखा करना है या उनका जवाब देना है) और "सोचने" जैसी ऐडवांस सुविधाएँ भी चालू होती हैं.
नेटिव ऑडियो, इन नेटिव ऑडियो मॉडल के साथ काम करता है:
- नई:
gemini-2.5-flash-native-audio-preview-09-2025
gemini-2.5-flash-preview-native-audio-dialog
gemini-2.5-flash-exp-native-audio-thinking-dialog
- नई:
- हाफ़-कैस्केड ऑडियो:
यह विकल्प, कैस्केड किए गए मॉडल आर्किटेक्चर (नेटिव ऑडियो इनपुट और टेक्स्ट-टू-स्पीच आउटपुट) का इस्तेमाल करता है.
यह प्रोडक्शन एनवायरमेंट में बेहतर परफ़ॉर्मेंस देता है और ज़्यादा भरोसेमंद है. खास तौर पर, टूल इस्तेमाल करने के दौरान. हाफ़-कैस्केड ऑडियो की सुविधा, इन मॉडल के साथ काम करती है:
gemini-live-2.5-flash-preview
gemini-2.0-flash-live-001
लागू करने का तरीका चुनना
Live API के साथ इंटिग्रेट करते समय, आपको लागू करने के लिए इनमें से कोई एक तरीका चुनना होगा:
- सर्वर-टू-सर्वर: आपका बैकएंड, WebSockets का इस्तेमाल करके Live API से कनेक्ट होता है. आम तौर पर, आपका क्लाइंट आपके सर्वर को स्ट्रीम डेटा (ऑडियो, वीडियो, टेक्स्ट) भेजता है. इसके बाद, सर्वर इसे Live API को भेजता है.
- क्लाइंट-टू-सर्वर: आपका फ़्रंटएंड कोड, डेटा स्ट्रीम करने के लिए WebSockets का इस्तेमाल करके, सीधे तौर पर Live API से कनेक्ट होता है. इसमें आपके बैकएंड को शामिल नहीं किया जाता.
अपनी प्रोफ़ाइल बनाना शुरू करें
इस उदाहरण में, WAV फ़ाइल को पढ़ा जाता है, उसे सही फ़ॉर्मैट में भेजा जाता है, और मिले हुए डेटा को WAV फ़ाइल के तौर पर सेव किया जाता है.
ऑडियो को 16-बिट पीसीएम, 16 किलोहर्ट्ज़, मोनो फ़ॉर्मैट में बदलकर भेजा जा सकता है. साथ ही, AUDIO
को जवाब देने के तरीके के तौर पर सेट करके ऑडियो पाया जा सकता है. आउटपुट में 24 किलोहर्ट्ज़ का सैंपल रेट इस्तेमाल किया जाता है.
Python
# 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();
आगे क्या करना है
- मुख्य सुविधाओं और कॉन्फ़िगरेशन के लिए, Live API की सुविधाओं से जुड़ी पूरी गाइड पढ़ें. इसमें आवाज़ की गतिविधि का पता लगाने और नेटिव ऑडियो सुविधाओं के बारे में जानकारी शामिल है.
- टूल और फ़ंक्शन कॉल करने की सुविधा के साथ Live API को इंटिग्रेट करने का तरीका जानने के लिए, टूल इस्तेमाल करने से जुड़ी गाइड पढ़ें.
- लंबे समय तक चलने वाली बातचीत को मैनेज करने के लिए, सेशन मैनेजमेंट गाइड पढ़ें.
- क्लाइंट-टू-सर्वर ऐप्लिकेशन में सुरक्षित तरीके से पुष्टि करने के लिए, कुछ समय के लिए मान्य टोकन गाइड पढ़ें.
- WebSockets API के बारे में ज़्यादा जानने के लिए, WebSockets API के बारे में जानकारी देखें.