Live API

Live API की मदद से, Gemini के साथ कम इंतज़ार के साथ, दोनों तरफ़ से आवाज़ और वीडियो के ज़रिए इंटरैक्ट किया जा सकता है. Live API का इस्तेमाल करके, उपयोगकर्ताओं को इंसानों जैसी आवाज़ में बातचीत करने का अनुभव दिया जा सकता है. साथ ही, वॉइस कमांड का इस्तेमाल करके, मॉडल के जवाबों में रुकावट डाली जा सकती है. यह मॉडल, टेक्स्ट, ऑडियो, और वीडियो इनपुट को प्रोसेस कर सकता है. साथ ही, यह टेक्स्ट और ऑडियो आउटपुट दे सकता है.

Google AI Studio में Live API को आज़माया जा सकता है.

नया क्या है

Live API में नई सुविधाएं और क्षमताएं जोड़ी गई हैं!

नई सुविधाएं:

• दो नई आवाज़ें और 30 नई भाषाएं. साथ ही, आउटपुट भाषा को कॉन्फ़िगर करने की सुविधा
• कॉन्फ़िगर की जा सकने वाली इमेज के रिज़ॉल्यूशन के लिए 66/256 टोकन
• कॉन्फ़िगर की जा सकने वाली टर्न कवरेज: सभी इनपुट हमेशा भेजें या सिर्फ़ तब भेजें, जब उपयोगकर्ता बोल रहा हो
• कॉन्फ़िगर करें कि इनपुट से मॉडल में रुकावट आएगी या नहीं
• कॉन्फ़िगर की जा सकने वाली वॉइस गतिविधि की पहचान करने की सुविधा और बोली पूरी होने के सिग्नल के लिए नए क्लाइंट इवेंट
• टोकन की संख्या
• स्ट्रीम खत्म होने की जानकारी देने वाला क्लाइंट इवेंट
• टेक्स्ट स्ट्रीमिंग
• कॉन्फ़िगर किए जा सकने वाले सेशन को फिर से शुरू करने की सुविधा. साथ ही, सेशन का डेटा 24 घंटे के लिए सर्वर पर सेव किया जाता है
• स्लाइड करने वाली कॉन्टेक्स्ट विंडो की मदद से, लंबे समय तक सेशन चलाने की सुविधा

नए क्लाइंट इवेंट:

• ऑडियो स्ट्रीम खत्म हो गई / माइक बंद हो गया
• मोड़ के ट्रांज़िशन को मैन्युअल तरीके से कंट्रोल करने के लिए, गतिविधि शुरू/खत्म होने के इवेंट

सर्वर के नए इवेंट:

• सेशन को फिर से शुरू करने की ज़रूरत का संकेत देने वाली सूचना
• जनरेशन पूरा हो गया

Live API का इस्तेमाल करना

इस सेक्शन में, हमारे किसी एक SDK टूल के साथ Live API का इस्तेमाल करने का तरीका बताया गया है. WebSockets API के बारे में ज़्यादा जानकारी के लिए, WebSockets API का रेफ़रंस देखें.

मैसेज भेजना और पाना

import asyncio
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY")
model = "gemini-2.0-flash-live-001"

config = {"response_modalities": ["TEXT"]}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        while True:
            message = input("User> ")
            if message.lower() == "exit":
                break
            await session.send_client_content(
                turns={"role": "user", "parts": [{"text": message}]}, turn_complete=True
            )

            async for response in session.receive():
                if response.text is not None:
                    print(response.text, end="")

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

ऑडियो पाना

इस उदाहरण में, ऑडियो डेटा पाने और उसे .wav फ़ाइल में लिखने का तरीका बताया गया है.

import asyncio
import wave
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY", http_options={'api_version': 'v1alpha'})
model = "gemini-2.0-flash-live-001"

config = {"response_modalities": ["AUDIO"]}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        wf = wave.open("audio.wav", "wb")
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(24000)

        message = "Hello? Gemini are you there?"
        await session.send_client_content(
            turns={"role": "user", "parts": [{"text": message}]}, turn_complete=True
        )

        async for idx,response in async_enumerate(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())

ऑडियो फ़ॉर्मैट

Live API इन ऑडियो फ़ॉर्मैट के साथ काम करता है:

• इनपुट ऑडियो फ़ॉर्मैट: 16kHz के लिटल-इंडियन फ़ॉर्मैट में रॉ 16 बिट PCM ऑडियो
• आउटपुट ऑडियो फ़ॉर्मैट: 24kHz के लिटल-इंडियन फ़ॉर्मैट में रॉ 16 बिट PCM ऑडियो

ऑडियो और वीडियो स्ट्रीम करना

सिस्टम से जुड़े निर्देश

सिस्टम के निर्देशों की मदद से, अपनी ज़रूरतों और इस्तेमाल के उदाहरणों के आधार पर, मॉडल के व्यवहार को कंट्रोल किया जा सकता है. सेटअप कॉन्फ़िगरेशन में सिस्टम के निर्देश सेट किए जा सकते हैं. ये निर्देश पूरे सेशन के लिए लागू रहेंगे.

from google.genai import types

config = {
    "system_instruction": types.Content(
        parts=[
            types.Part(
                text="You are a helpful assistant and answer in a friendly tone."
            )
        ]
    ),
    "response_modalities": ["TEXT"],
}

कॉन्टेंट के इंक्रीमेंटल अपडेट

टेक्स्ट इनपुट भेजने, सेशन का कॉन्टेक्स्ट सेट करने या सेशन का कॉन्टेक्स्ट वापस लाने के लिए, इंक्रीमेंटल अपडेट का इस्तेमाल करें. कम शब्दों वाले कॉन्टेक्स्ट के लिए, इवेंट के सटीक क्रम को दिखाने के लिए, बारी-बारी से इंटरैक्शन भेजे जा सकते हैं:

turns = [
    {"role": "user", "parts": [{"text": "What is the capital of France?"}]},
    {"role": "model", "parts": [{"text": "Paris"}]},
]

await session.send_client_content(turns=turns, turn_complete=False)

turns = [{"role": "user", "parts": [{"text": "What is the capital of Germany?"}]}]

await session.send_client_content(turns=turns, turn_complete=True)

{
  "clientContent": {
    "turns": [
      {
        "parts":[
          {
            "text": ""
          }
        ],
        "role":"user"
      },
      {
        "parts":[
          {
            "text": ""
          }
        ],
        "role":"model"
      }
    ],
    "turnComplete": true
  }
}

लंबे कॉन्टेक्स्ट के लिए, हमारा सुझाव है कि आप एक मैसेज की खास जानकारी दें, ताकि बाद के इंटरैक्शन के लिए कॉन्टेक्स्ट विंडो खाली हो सके.

आवाज़ें बदलना

Live API में ये आवाज़ें उपलब्ध हैं: Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus, और Zephyr.

किसी आवाज़ को सेट करने के लिए, सेशन कॉन्फ़िगरेशन के हिस्से के तौर पर, speechConfig ऑब्जेक्ट में आवाज़ का नाम सेट करें:

from google.genai import types

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    speech_config=types.SpeechConfig(
        voice_config=types.VoiceConfig(
            prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name="Kore")
        )
    )
)

{
  "voiceConfig": {
    "prebuiltVoiceConfig": {
      "voiceName": "Kore"
    }
  }
}

भाषा बदलें

Live API, कई भाषाओं में काम करता है.

भाषा बदलने के लिए, सेशन कॉन्फ़िगरेशन के हिस्से के तौर पर, speechConfig ऑब्जेक्ट में भाषा कोड सेट करें:

from google.genai import types

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    speech_config=types.SpeechConfig(
        language_code="de-DE",
    )
)

फ़ंक्शन कॉल का इस्तेमाल करना

Live API की मदद से टूल तय किए जा सकते हैं. फ़ंक्शन कॉल करने के बारे में ज़्यादा जानने के लिए, फ़ंक्शन कॉल करने के बारे में ट्यूटोरियल देखें.

टूल को सेशन कॉन्फ़िगरेशन के हिस्से के तौर पर तय किया जाना चाहिए:

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    tools=[set_light_values]
)

async with client.aio.live.connect(model=model, config=config) as session:
    await session.send_client_content(
        turns={
            "role": "user",
            "parts": [{"text": "Turn the lights down to a romantic level"}],
        },
        turn_complete=True,
    )

    async for response in session.receive():
        print(response.tool_call)

एक प्रॉम्प्ट से, मॉडल कई फ़ंक्शन कॉल और उनके आउटपुट को चेन करने के लिए ज़रूरी कोड जनरेट कर सकता है. यह कोड सैंडबॉक्स एनवायरमेंट में चलता है और इसके बाद BidiGenerateContentToolCall मैसेज जनरेट करता है. फ़ंक्शन कॉल के नतीजे उपलब्ध होने तक, एक्ज़ीक्यूशन रोक दिया जाता है. इससे क्रम से प्रोसेस करने की सुविधा मिलती है.

क्लाइंट को BidiGenerateContentToolResponse के साथ जवाब देना चाहिए.

ऑडियो इनपुट और ऑडियो आउटपुट, फ़ंक्शन कॉलिंग का इस्तेमाल करने की मॉडल की क्षमता पर बुरा असर डालते हैं.

रुकावटों को मैनेज करना

उपयोगकर्ता किसी भी समय मॉडल के आउटपुट में रुकावट डाल सकते हैं. जब आवाज़ की गतिविधि का पता लगाने (वीएडी) की सुविधा किसी रुकावट का पता लगाती है, तो जनरेट की जा रही फ़ाइल को रद्द कर दिया जाता है और उसे हटा दिया जाता है. सेशन के इतिहास में सिर्फ़ वह जानकारी सेव रहती है जो क्लाइंट को पहले ही भेजी जा चुकी है. इसके बाद, रुकावट की शिकायत करने के लिए, सर्वर एक BidiGenerateContentServerContent मैसेज भेजता है.

इसके अलावा, Gemini सर्वर उन सभी फ़ंक्शन कॉल को खारिज कर देता है जो प्रोसेस नहीं हो पाए हैं. साथ ही, रद्द किए गए कॉल के आईडी के साथ एक BidiGenerateContentServerContent मैसेज भेजता है.

async for response in session.receive():
    if response.server_content.interrupted is True:
        # The generation was interrupted

आवाज़ की गतिविधि का पता लगाने की सुविधा (वीएडी) कॉन्फ़िगर करना

डिफ़ॉल्ट रूप से, मॉडल लगातार चल रही ऑडियो इनपुट स्ट्रीम पर, आवाज़ की गतिविधि का पता लगाने (वीएडी) की सुविधा अपने-आप चालू कर देता है. VAD को सेटअप कॉन्फ़िगरेशन के realtimeInputConfig.automaticActivityDetection फ़ील्ड की मदद से कॉन्फ़िगर किया जा सकता है.

जब ऑडियो स्ट्रीम को एक सेकंड से ज़्यादा समय के लिए रोका जाता है (उदाहरण के लिए, उपयोगकर्ता ने माइक्रोफ़ोन बंद कर दिया है), तो कैश मेमोरी में सेव किए गए किसी भी ऑडियो को फ़्लश करने के लिए, audioStreamEnd इवेंट भेजा जाना चाहिए. क्लाइंट, ऑडियो डेटा भेजना कभी भी फिर से शुरू कर सकता है.

इसके अलावा, सेटअप मैसेज में realtimeInputConfig.automaticActivityDetection.disabled को true पर सेट करके, अपने-आप आवाज़ पहचानने की सुविधा को बंद किया जा सकता है. इस कॉन्फ़िगरेशन में, उपयोगकर्ता की बातचीत का पता लगाने और सही समय पर activityStart और activityEnd मैसेज भेजने की ज़िम्मेदारी क्लाइंट की होती है. इस कॉन्फ़िगरेशन में audioStreamEnd नहीं भेजा जाता. इसके बजाय, स्ट्रीम में किसी भी तरह की रुकावट आने पर, activityEnd मैसेज के ज़रिए उसे मार्क किया जाता है.

इस सुविधा के लिए SDK टूल, आने वाले हफ़्तों में उपलब्ध होगा.

टोकन की संख्या देखना

इस्तेमाल किए गए टोकन की कुल संख्या, सर्वर से मिले मैसेज के usageMetadata फ़ील्ड में देखी जा सकती है.

async for message in session.receive():
    # The server will periodically send messages that include UsageMetadata.
    if message.usage_metadata:
        usage = message.usage_metadata
        print(
            f"Used {usage.total_token_count} tokens in total. Response token breakdown:"
        )
        for detail in usage.response_tokens_details:
            match detail:
                case types.ModalityTokenCount(modality=modality, token_count=count):
                    print(f"{modality}: {count}")

सेशन की अवधि बढ़ाना

सेशन की ज़्यादा से ज़्यादा अवधि को अनलिमिटेड किया जा सकता है. इसके लिए, दो तरीके अपनाए जा सकते हैं:

• कॉन्टेक्स्ट विंडो कंप्रेस करने की सुविधा चालू करना
• सेशन फिर से शुरू करने की सुविधा कॉन्फ़िगर करना

इसके अलावा, सेशन खत्म होने से पहले आपको GoAway मैसेज मिलेगा. इससे आपको आगे की कार्रवाइयां करने में मदद मिलेगी.

कॉन्टेक्स्ट विंडो कंप्रेस करने की सुविधा चालू करना

लंबे सेशन चालू करने और अचानक कनेक्शन बंद होने से बचने के लिए, सेशन कॉन्फ़िगरेशन के हिस्से के तौर पर contextWindowCompression फ़ील्ड को सेट करके, कॉन्टेक्स्ट विंडो कंप्रेसन चालू किया जा सकता है.

ContextWindowCompressionConfig में, स्लाइडिंग-विंडो मेकेनिज्म और टोकन की संख्या को कॉन्फ़िगर किया जा सकता है. इससे कंप्रेस करने की सुविधा चालू होती है.

from google.genai import types

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    context_window_compression=(
        # Configures compression with default parameters.
        types.ContextWindowCompressionConfig(
            sliding_window=types.SlidingWindow(),
        )
    ),
)

सेशन फिर से शुरू करने की सुविधा कॉन्फ़िगर करना

जब सर्वर समय-समय पर WebSocket कनेक्शन को रीसेट करता है, तो सेशन खत्म होने से रोकने के लिए, सेटअप कॉन्फ़िगरेशन में sessionResumption फ़ील्ड को कॉन्फ़िगर करें.

इस कॉन्फ़िगरेशन को पास करने पर, सर्वर SessionResumptionUpdate मैसेज भेजता है. इन मैसेज का इस्तेमाल, सेशन को फिर से शुरू करने के लिए किया जा सकता है. इसके लिए, पिछले सेशन को फिर से शुरू करने वाले टोकन को अगले कनेक्शन के SessionResumptionConfig.handle के तौर पर पास करना होगा.

from google.genai import types

print(f"Connecting to the service with handle {previous_session_handle}...")
async with client.aio.live.connect(
    model="gemini-2.0-flash-live-001",
    config=types.LiveConnectConfig(
        response_modalities=["AUDIO"],
        session_resumption=types.SessionResumptionConfig(
            # The handle of the session to resume is passed here,
            # or else None to start a new session.
            handle=previous_session_handle
        ),
    ),
) as session:
    # Session connected
    while True:
        await session.send_client_content(
            turns=types.Content(
                role="user", parts=[types.Part(text="Hello world!")]
            )
        )
        async for message in session.receive():
            # Periodically, the server will send update messages that may
            # contain a handle for the current state of the session.
            if message.session_resumption_update:
                update = message.session_resumption_update
                if update.resumable and update.new_handle:
                    # The handle should be retained and linked to the session.
                    return update.new_handle

            # For the purposes of this example, placeholder input is continually fed
            # to the model. In non-sample code, the model inputs would come from
            # the user.
            if message.server_content and message.server_content.turn_complete:
                break

सेशन डिसकनेक्ट होने से पहले मैसेज पाना

सर्वर, GoAway मैसेज भेजता है. इससे पता चलता है कि मौजूदा कनेक्शन जल्द ही बंद हो जाएगा. इस मैसेज में timeLeft शामिल होता है, जो बाकी बचे समय के बारे में बताता है. साथ ही, 'रद्द किया गया' के तौर पर कनेक्शन खत्म होने से पहले, आपको आगे की कार्रवाई करने की सुविधा देता है.

async for response in session.receive():
    if response.go_away is not None:
        # The connection will soon be terminated
        print(response.go_away.time_left)

जनरेट होने के बाद मैसेज पाना

सर्वर, generationComplete मैसेज भेजता है. इससे पता चलता है कि मॉडल ने जवाब जनरेट कर लिया है.

async for response in session.receive():
    if response.server_content.generation_complete is True:
        # The generation is complete

मीडिया का रिज़ॉल्यूशन बदलना

सेशन कॉन्फ़िगरेशन के हिस्से के तौर पर mediaResolution फ़ील्ड को सेट करके, इनपुट मीडिया के लिए मीडिया रिज़ॉल्यूशन तय किया जा सकता है:

from google.genai import types

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    media_resolution=types.MediaResolution.MEDIA_RESOLUTION_LOW,
)

सीमाएं

अपना प्रोजेक्ट प्लान करते समय, Live API और Gemini 2.0 की इन सीमाओं का ध्यान रखें.

जवाब देने के तरीके

सेशन कॉन्फ़िगरेशन में, हर सेशन के लिए सिर्फ़ एक जवाब मोड (TEXT या AUDIO) सेट किया जा सकता है. दोनों को सेट करने की कोशिश करने पर, कॉन्फ़िगरेशन से जुड़ी गड़बड़ी का मैसेज दिखेगा. इसका मतलब है कि मॉडल को टेक्स्ट या ऑडियो में जवाब देने के लिए कॉन्फ़िगर किया जा सकता है, लेकिन एक ही सेशन में दोनों में जवाब नहीं दिया जा सकता.

क्लाइंट प्रमाणीकरण

लाइव एपीआई सिर्फ़ सर्वर से सर्वर की पुष्टि करता है और इसका सुझाव सीधे क्लाइंट के इस्तेमाल के लिए नहीं दिया जाता. Live API की मदद से सुरक्षित तरीके से पुष्टि करने के लिए, क्लाइंट इनपुट को किसी इंटरमीडियरी ऐप्लिकेशन सर्वर के ज़रिए रूट किया जाना चाहिए.

सत्र की अवधि

सेशन कंप्रेस करने की सुविधा चालू करके, सेशन की अवधि को अनलिमिटेड किया जा सकता है. बिना कंप्रेस किए, सिर्फ़ ऑडियो वाले सेशन 15 मिनट तक के हो सकते हैं. साथ ही, ऑडियो और वीडियो वाले सेशन दो मिनट तक के हो सकते हैं. कंप्रेस किए बिना इन सीमाओं से ज़्यादा डेटा भेजने पर, कनेक्शन बंद हो जाएगा.

इसके अलावा, सेशन फिर से शुरू करने की सुविधा को कॉन्फ़िगर करके, क्लाइंट को उस सेशन को फिर से शुरू करने की अनुमति दी जा सकती है जिसे बंद कर दिया गया था.

कॉन्टेक्स्ट विंडो

किसी सेशन की कॉन्टेक्स्ट विंडो की सीमा 32 हज़ार टोकन होती है.

इस्तेमाल की जा सकने वाली भाषाएं

Live API इन भाषाओं में काम करता है:

तीसरे पक्ष के इंटिग्रेशन

वेब और मोबाइल ऐप्लिकेशन को डिप्लॉय करने के लिए, इन विकल्पों को एक्सप्लोर किया जा सकता है:

• हर रोज़
• Livekit