Grok Voice Agent API: रियल-टाइम वॉइस असिस्टेंट बनाने का तरीका

वॉइस AI एजेंट इस समय सुर्खियों में हैं। उपयोगकर्ता अपनी ऐप्स से टाइप करने के बजाय बात करना चाहते हैं, और अब तकनीक इतनी अच्छी हो गई है कि ये बातचीत स्वाभाविक लगती हैं।

यदि आप एक बनाना चाहते हैं, तो xAI का Grok Voice Agent API एक मजबूत शुरुआत है। यह सब-सेकंड प्रतिक्रिया समय और अधिकांश विकल्पों की तुलना में कम लागत देता है, साथ ही मौजूदा OpenAI कोड के साथ ड्रॉप-इन संगतता भी।

यह ट्यूटोरियल आपको शुरू से एक काम करने वाला वॉइस एजेंट बनाना सिखाता है। आप ऑथेंटिकेशन जोड़ेंगे, व्यक्तित्व और वॉइस विकल्प कॉन्फ़िगर करेंगे, टूल कॉलिंग जोड़ेंगे, और LiveKit Cloud के साथ प्रोडक्शन में डिप्लॉय करेंगे। यह API Grok 3 पर चलता है, जिसे xAI ने सामान्य टेक्स्ट-इन, टेक्स्ट-आउट वर्कफ़्लो के बजाय रियल-टाइम वॉइस बातचीत के लिए अनुकूलित किया है।

Grok Voice Agent API क्या है?

Grok Voice Agent API xAI का रियल-टाइम वॉइस बातचीत प्लेटफ़ॉर्म है, जो दिसंबर 2025 में जारी किया गया। यह ऑडियो को सीधे प्रोसेस करता है, सामान्य स्पीच-टू-टेक्स्ट और वापस टेक्स्ट-टू-स्पीच रूपांतरण के बिना, जिससे प्रतिक्रिया समय घटता है और बातचीत स्वाभाविक बनी रहती है।

पारंपरिक वॉइस AI सिस्टम तीन अलग-अलग चरण जोड़ते हैं: भाषण को टेक्स्ट में ट्रांसक्राइब करना, उस टेक्स्ट को भाषा मॉडल से चलाना, फिर प्रतिक्रिया को फिर से ऑडियो में सिंथेसाइज़ करना। यह तरीका काम करता है, लेकिन हर कंपोनेंट के बीच हैंडऑफ़ देरी जोड़ता है। ट्रांसक्रिप्शन, प्रोसेसिंग और सिंथेसिस को जोड़ें, तो उपयोगकर्ता को प्रतिक्रिया मिलने में 500ms से 1,000ms लग सकते हैं। ये रुकावटें जुड़ती जाती हैं और बातचीत को यांत्रिक बनाती हैं।

Grok Voice Agent इन रूपांतरणों को पूरी तरह छोड़ देता है। सिस्टम ऑडियो लेता है, ऑडियो डोमेन में तर्क करता है, और एक ही मॉडल से ऑडियो आउटपुट देता है जिसे वार्तालापी भाषण पर प्रशिक्षित किया गया है। यह आर्किटेक्चर औसतन 0.78 सेकंड का टाइम-टू-फर्स्ट-ऑडियो देता है और फुल-डुप्लेक्स संचार (एक साथ द्विदिश ऑडियो, जहां एजेंट एक ही समय में सुन और बोल सकता है) को सपोर्ट करता है, ताकि एजेंट सख्त टर्न-टेकिंग का इंतज़ार किए बिना प्रतिक्रिया दे सके।

अपना Grok Voice Agent वातावरण सेटअप करना

Grok के साथ वॉइस एजेंट बनाने के लिए इसे LiveKit, एक ओपन-सोर्स WebRTC प्लेटफ़ॉर्म, के साथ पेयर करना पड़ता है। Grok वार्तालापी AI मॉडल देता है, जबकि LiveKit वह रियल-टाइम ऑडियो इन्फ्रास्ट्रक्चर संभालता है जो उपयोगकर्ताओं को आपके एजेंट से जोड़ता है। इस खंड में दोनों सेवाएँ सेटअप करना शामिल है।

Grok सेटअप करना

भ्रमण करें console.x.ai और X, ईमेल, Google, या Apple ऑथेंटिकेशन का उपयोग करके एक खाता बनाएं। xAI कंसोल में API कॉल करने से पहले प्रीपेड क्रेडिट की आवश्यकता होती है। बिलिंग सेक्शन के माध्यम से क्रेडिट ख़रीदें।

खाते में क्रेडिट होने पर, API Keys पर जाएँ और नई कुंजी जनरेट करें। कंसोल कुंजी केवल एक बार दिखाता है, इसलिए उसे तुरंत कॉपी करके सुरक्षित रूप से स्टोर कर लें। यदि खो जाए, तो आपको प्रतिस्थापन जनरेट करना होगा और अपनी एप्लिकेशनों को अपडेट करना होगा। xAI के API इकोसिस्टम का विस्तृत वॉकथ्रू देखने के लिए Grok 3 API ट्यूटोरियल देखें।

LiveKit सेटअप करना

LiveKit रियल-टाइम ऑडियो और वीडियो के लिए WebRTC इन्फ्रास्ट्रक्चर है। यह वह ऑडियो ट्रांसपोर्ट लेयर संभालता है जिसकी Grok को उपयोगकर्ताओं से कनेक्ट होने के लिए ज़रूरत है। वॉइस एजेंट बनाते समय, LiveKit उन रूम्स को मैनेज करता है जहाँ बातचीत होती है, प्रतिभागियों के बीच ऑडियो स्ट्रीम रूट करता है, और डिप्लॉयमेंट इन्फ्रास्ट्रक्चर प्रदान करता है। LiveKit Agents फ़्रेमवर्क इस जटिलता को रैप करता है, जिससे आप कनेक्शन मैनेजमेंट, ऑडियो एन्कोडिंग और टर्न डिटेक्शन संभालते हुए एजेंट के व्यवहार पर ध्यान केंद्रित कर सकते हैं।

यह फ़्रेमवर्क xAI सहित कई AI प्रदाताओं को सपोर्ट करता है। इसमें एक वेब इंटरफ़ेस के माध्यम से सुलभ टेस्टिंग प्लेग्राउंड शामिल है, जिसका उपयोग आप डिप्लॉय करने से पहले अपने एजेंट को वैलिडेट करने के लिए करेंगे।

साइन अप करें cloud.livekit.io पर। फ्री टियर विकास और परीक्षण के लिए पर्याप्त संसाधन देता है। डैशबोर्ड के माध्यम से एक प्रोजेक्ट बनाएं। Settings पर जाएँ, फिर API Keys पर। तीन क्रेडेंशियल्स कॉपी करें: LIVEKIT_URL (आपके प्रोजेक्ट का WebSocket एंडपॉइंट), LIVEKIT_API_KEY (पब्लिक आइडेंटिफायर), और LIVEKIT_API_SECRET (प्राइवेट ऑथेंटिकेशन कुंजी)। ये क्रेडेंशियल्स आपके एजेंट कोड को आपके LiveKit Cloud प्रोजेक्ट के साथ ऑथेंटिकेट करते हैं।

डिपेंडेंसियाँ और कॉन्फ़िगरेशन इंस्टॉल करना

आवश्यक पैकेज इंस्टॉल करें:

uv add "livekit-agents[xai,openai]>=1.3.10" python-dotenv

यह LiveKit agents फ़्रेमवर्क को xAI प्लगइन और OpenAI डिपेंडेंसियों के साथ इंस्टॉल करता है (xAI प्लगइन OpenAI के Realtime API कम्पैटिबिलिटी पर आधारित है), साथ ही environment variable मैनेजमेंट के लिए python-dotenv भी।

अपने प्रोजेक्ट रूट में एक .env फ़ाइल बनाएं:

XAI_API_KEY=xai-YourActualKeyHere
 LIVEKIT_URL=wss://your-project.livekit.cloud
 LIVEKIT_API_KEY=APIYourKeyHere
 LIVEKIT_API_SECRET=YourSecretHere

प्लेसहोल्डर मानों को अपने वास्तविक क्रेडेंशियल्स से बदलें। अपनी Python कोड में इन क्रेडेंशियल्स को लोड करें:

from dotenv import load_dotenv
 load_dotenv()

यह क्रेडेंशियल्स को xAI और LiveKit दोनों लाइब्रेरी के लिए उपलब्ध कराता है। संस्करण नियंत्रण में क्रेडेंशियल लीक से बचने के लिए .env को अपने .gitignore में जोड़ें।

अपना पहला Grok Voice Agent बनाना

वातावरण कॉन्फ़िगर होने के बाद, आप एक काम करने वाला वॉइस एजेंट बना सकते हैं। एक नए फ़ाइल agent.py में इम्पोर्ट्स और एजेंट क्लास से शुरू करें:

from livekit.agents import Agent, AgentSession, AgentServer, JobContext, cli
from livekit.plugins.xai import realtime
from dotenv import load_dotenv

load_dotenv()

class ResearchAssistant(Agent):
	def __init__(self):
    	super().__init__(
        	instructions="You are a research assistant who helps users find information.",
 	)

आपके Agent सबक्लास में केवल वे निर्देश होते हैं जो एजेंट की प्रतिक्रिया शैली तय करते हैं। ये सिस्टम प्रॉम्प्ट की तरह काम करते हैं, जो एजेंट को उसकी भूमिका बताते हैं। वास्तविक मॉडल कॉन्फ़िगरेशन कहीं और जाता है।

अब सर्वर और कनेक्शन हैंडलर सेट करें:

server = AgentServer()


@server.rtc_session()
async def entrypoint(ctx: JobContext):
	await ctx.connect()

 	session = AgentSession(
         llm=realtime.RealtimeModel(voice="ara"),
 	)

 	await session.start(
     	room=ctx.room,
     	agent=ResearchAssistant(),
 	)

@server.rtc_session() डेकोरेटर LiveKit को बताता है कि जब भी कोई कनेक्ट हो, आपकी एंट्रीपॉइंट फ़ंक्शन चलाए। अंदर, AgentSession मॉडल कॉन्फ़िगरेशन लेता है, जिसमें Grok की सात में से किस वॉइस का उपयोग करना है (Ara, Eve, Leo, Sal, Rex, Mika, या Valentin) शामिल है। जब session.start() चलता है, तो यह आपके एजेंट को उस LiveKit रूम से जोड़ता है जहाँ बातचीत होती है।

वॉइस बातचीत में ऑडियो इनपुट और आउटपुट का इंतज़ार करना शामिल होता है, बिना प्रोग्राम को फ्रीज़ किए, इसलिए फ़ंक्शन async def और await का उपयोग करता है ताकि ये ऑपरेशन समवर्ती रूप से संभाले जा सकें।

अंत में, एंट्री पॉइंट जोड़ें:

if __name__ == "__main__":
 	cli.run_app(server)

अपना एजेंट डेवलपमेंट मोड में चलाएँ:

uv run agent.py dev

टर्मिनल में स्टार्टअप सीक्वेंस दिखेगा: वर्कर इनिशियलाइज़ेशन, HTTP सर्वर लोकल पोर्ट पर सुनना, और आपके LiveKit Cloud प्रोजेक्ट के साथ रजिस्ट्रेशन।

एजेंट का परीक्षण करने के लिए, अपने LiveKit Cloud डैशबोर्ड पर जाएँ cloud.livekit.io। अपना प्रोजेक्ट चुनें, फिर साइडबार में Sandbox टैब पर क्लिक करें। टेम्पलेट्स से Web Voice Agent चुनें।

टेम्पलेट पेज पर वॉइस इंटरफ़ेस का प्रीव्यू और इसमें क्या शामिल है, उसका विवरण दिखता है। Create sandbox बटन पर क्लिक करें।

प्रकट होने वाले मोडल में, आप कस्टम URL कॉन्फ़िगर कर सकते हैं, कैमरा और स्क्रीन शेयरिंग जैसी क्षमताएँ सक्षम कर सकते हैं, और स्वरूप सेटिंग्स समायोजित कर सकते हैं। परीक्षण के लिए डिफ़ॉल्ट ठीक काम करते हैं, इसलिए Create पर क्लिक करें, फिर Done।

Sandbox पेज पर वापस, आपका नया सैंडबॉक्स Sandbox apps के अंतर्गत दिखाई देगा। उसे खोलने के लिए Launch पर क्लिक करें।

Start Call पर क्लिक करें और संकेत मिलने पर माइक्रोफ़ोन अनुमतियाँ दें। इस लॉग संदेश के लिए टर्मिनल देखें, जो इंगित करता है कि एजेंट ऑडियो प्राप्त करने के लिए तैयार है:

DEBUG livekit.agents start reading stream {"participant": "...", "source": "SOURCE_MICROPHONE", ...}

यह संदेश आने के बाद, प्रतिक्रियाएँ तेजी से आती हैं।

जब आप ऐसी किसी चीज़ के बारे में पूछते हैं जिसे एजेंट एक्सेस नहीं कर सकता (जैसे किसी विशिष्ट शहर में वर्तमान मौसम), तो यह बातें बनाने के बजाय अपनी सीमाएँ समझाता है।

अपने Grok वॉइस एजेंट्स में टूल्स कैसे जोड़ें

बेसिक एजेंट बातचीत कर सकता है लेकिन चीज़ें खोजने का कोई तरीका नहीं होता। टूल कॉलिंग Grok को बातचीत के बीच में फ़ंक्शन्स चलाने और परिणामों के बारे में बोलने देती है। आप xAI के बिल्ट-इन टूल्स का उपयोग कर सकते हैं या अपने खुद के परिभाषित कर सकते हैं।

बिल्ट-इन टूल्स का उपयोग

xAI प्लगइन में सामान्य वेब क्वेरी के लिए WebSearch और X पर पोस्ट खोजने के लिए XSearch शामिल हैं। इन्हें इम्पोर्ट करें और AgentSession में पास करें:

from livekit.agents import Agent, AgentSession, AgentServer, JobContext, cli
from livekit.plugins.xai import realtime
from livekit.plugins.xai.realtime import WebSearch, XSearch
from dotenv import load_dotenv

load_dotenv()


class ResearchAssistant(Agent):
 	def __init__(self):
     	super().__init__(
             instructions="""You are a research assistant with access to web search and X search.

- Use web search for general queries and current information
- Use X search when users ask about posts or what people are saying on X/Twitter

Always mention your sources when providing information.""",
     	)


server = AgentServer()


@server.rtc_session()
async def entrypoint(ctx: JobContext):
	await ctx.connect()

	session = AgentSession(
         llm=realtime.RealtimeModel(voice="ara"),
     	tools=[
         	WebSearch(),
         	XSearch(),
     	],
 	)

 	await session.start(
     	room=ctx.room,
     	agent=ResearchAssistant(),
 	)


if __name__ == "__main__":
 	cli.run_app(server)

tools पैरामीटर टूल ऑब्जेक्ट्स की सूची स्वीकार करता है। एजेंट चलाएँ और ऐसे प्रश्नों से टेस्ट करें जैसे "AI के बारे में ताज़ा खबरें क्या हैं?" या "X पर लोग Grok के बारे में क्या कह रहे हैं?" टर्मिनल लॉग्स में web_search_with_snippets या x_semantic_search जैसी अज्ञात AI फ़ंक्शन्स के बारे में चेतावनियाँ दिख सकती हैं, लेकिन टूल्स फिर भी वर्तमान जानकारी लौटाते हैं।

टूल्स का उपयोग करते समय Grok का फुल-डुप्लेक्स ऑडियो भी स्पष्ट हो जाता है। आप एजेंट को बोलते समय बीच में टोक सकते हैं, और यह रुकता है, सुनता है, और अपनी प्रतिक्रिया समायोजित करता है। इससे वे सिस्टम की तुलना में बातचीत कम रोबोटिक लगती है, जिनमें बोलने से पहले एजेंट के समाप्त होने का इंतज़ार करना पड़ता है।

कस्टम टूल्स जोड़ना

बिल्ट-इन टूल्स सामान्य उपयोग मामलों को कवर करते हैं, लेकिन अपने टूल्स परिभाषित करने से आपको पैरामीटर्स, एरर हैंडलिंग और किन APIs को कॉल करना है उस पर नियंत्रण मिलता है। यह खंड Firecrawl के सर्च एंडपॉइंट का उपयोग करते हुए कस्टम टूल निर्माण दिखाता है, जो limit, lang और country जैसी फ़िल्टरिंग विकल्प देता है, जिन्हें बिल्ट-इन वेब सर्च एक्सपोज़ नहीं करता।

साइन अप करें firecrawl.dev पर। फ्री टियर में 500 क्रेडिट शामिल हैं और क्रेडिट कार्ड की आवश्यकता नहीं है। SDK इंस्टॉल करें और अपनी कुंजी .env में जोड़ें:

uv add firecrawl-py

FIRECRAWL_API_KEY=fc-your-key-here

कस्टम टूल्स वे मेथड होते हैं जिन पर @function_tool() डेकोरेटर लगाया जाता है। search_agent.py में इम्पोर्ट्स अपडेट करें:

from livekit.agents import (
 	Agent,
 	AgentSession,
 	AgentServer,
 	JobContext,
 	cli,
 	function_tool,
 	RunContext,
 )

from livekit.plugins.xai import realtime
from livekit.plugins.xai.realtime import XSearch
from firecrawl import FirecrawlApp
from dotenv import load_dotenv

import os 
load_dotenv()

अतिरिक्त इम्पोर्ट्स हैं function_tool डेकोरेटर के लिए, RunContext जो टूल फ़ंक्शन्स को पास होता है, और FirecrawlApp Firecrawl क्लाइंट के लिए। WebSearch हटा दिया गया है क्योंकि इसे कस्टम टूल से बदला गया है।

अपने एजेंट क्लास पर एक मेथड के रूप में टूल परिभाषित करें:

class ResearchAssistant(Agent):
 	def __init__(self):
     	super().__init__(
             instructions="""You are a research assistant with access to web search and X search.

 - Use Firecrawl search for general queries and current information
 - Use X search when users ask about posts or what people are saying on X/Twitter

 Always mention your sources when providing information.""",
     	)
     	self.firecrawl = FirecrawlApp(api_key=os.getenv("FIRECRAWL_API_KEY"))

 	@function_tool()
     async def search_web(
     	self,
     	context: RunContext,
     	query: str,
 	) -> dict:
     	"""Search the web for current information using Firecrawl.

     	Args:
         	query: The search query
     	"""
     	result = self.firecrawl.search(query, limit=3)
     	return {
         	"results": [
             	{
                 	"title": item.title,
                 	"url": item.url,
                     "description": item.description,
             	}
             	for item in result.web
         	]
     	}

Grok समझने के लिए डॉक्स्ट्रिंग पढ़ता है कि टूल क्या करता है। जब आप पूछते हैं, "वर्तमान USD से EURO विनिमय दर क्या है?", तो Grok क्वेरी निकालता है, आपका फ़ंक्शन कॉल करता है, और अपने उत्तर में परिणामों को सम्मिलित करता है।

@function_tool() से सजाए गए मेथड्स अपने आप रजिस्टर हो जाते हैं, इसलिए टूल्स सूची से WebSearch() हटा दें:

session = AgentSession(
     llm=realtime.RealtimeModel(voice="ara"),
 	tools=[
     	XSearch(),
 	],
 )

अपडेटेड एजेंट चलाएँ:

uv run search_agent.py dev

टर्मिनल में टूल एक्ज़िक्यूशन दिखेगा:

DEBUG livekit.agents executing tool {
 	"function": "search_web",
 	"arguments": "{\"query\":\"current USD to EURO exchange rate\"}",
 	...
 }
DEBUG livekit.agents tools execution completed {...}

मेरे परीक्षणों में, Firecrawl ने लगभग दो सेकंड में परिणाम लौटाए। आप एक ही एजेंट में कई कस्टम टूल्स को बिल्ट-इन टूल्स के साथ मिला सकते हैं। उदाहरण के लिए, एक कस्टमर सपोर्ट एजेंट XSearch के साथ-साथ आंतरिक डेटाबेस से जुड़ने वाले कस्टम lookup_order() और check_inventory() टूल्स का उपयोग कर सकता है।

टर्न डिटेक्शन को कस्टमाइज़ करना

डिफ़ॉल्ट टर्न डिटेक्शन सेटिंग्स सामान्य बातचीत को अच्छी तरह संभालती हैं। समायोजन तब आवश्यक होते हैं जब वातावरण या उपयोगकर्ता का व्यवहार सामान्य से अलग हो। शोरगुल वाले कमरे में एजेंट बैकग्राउंड साउंड्स पर प्रतिक्रिया दे सकता है, जबकि कोई उपयोगकर्ता जो सोचने के लिए रुकता है, उसे पूरा करने से पहले रोका जा सकता है।

from livekit.plugins.xai import realtime
from openai.types.beta.realtime.session import TurnDetection

session = AgentSession(
 	llm=realtime.RealtimeModel(
     	voice="ara",
     	turn_detection=TurnDetection(
         	type="server_vad",
         	threshold=0.5,
         	prefix_padding_ms=300,
         	silence_duration_ms=200,
     	),
 	),
 )

threshold पैरामीटर सेट करता है कि भाषण माने जाने से पहले ऑडियो कितना तेज होना चाहिए, 0.0 से 1.0 तक। इस मान को 0.7 या उससे अधिक करना शोरगुल वाले वातावरण में मदद करता है जहाँ बैकग्राउंड साउंड्स अन्यथा प्रतिक्रियाओं को ट्रिगर कर सकते हैं।

prefix_padding_ms पैरामीटर निर्धारित करता है कि भाषण की शुरुआत का पता चलने से पहले कितना ऑडियो कैप्चर करना है। डिफ़ॉल्ट 300ms पहला अक्षर कटा न जाए, यह सुनिश्चित करता है। यदि उपयोगकर्ता बताते हैं कि उनके शुरुआती शब्द कट रहे हैं, तो इसे बढ़ाएँ।

silence_duration_ms पैरामीटर नियंत्रित करता है कि आपके बोलना बंद करने के बाद एजेंट प्रतिक्रिया देने से पहले कितना इंतज़ार करता है। 200ms पर, बातचीत प्रतिक्रियावादी लगती है। इसे 400 या 500ms तक बढ़ाना उन उपयोगकर्ताओं के लिए अनुकूल है जो वाक्य के बीच में रुकते हैं या धीमी गति से बोलते हैं।

पुश-टू-टॉक इंटरफ़ेस या टेलीफोनी सिस्टम्स के लिए, जहाँ आपको बातचीत के प्रवाह पर स्पष्ट नियंत्रण चाहिए, स्वचालित टर्न डिटेक्शन अक्षम करें:

session = AgentSession(
 	llm=realtime.RealtimeModel(
     	voice="ara",
     	turn_detection=None,
 	),
 )

तब एजेंट मौन सुनने के बजाय प्रतिक्रिया देने के लिए प्रोग्रामेटिक सिग्नल का इंतज़ार करेगा।

Grok Voice Agent को प्रोडक्शन में डिप्लॉय करना

डेवलपमेंट मोड एजेंट को आपकी लोकल मशीन से बाँधता है। प्रोडक्शन डिप्लॉयमेंट के लिए जो 24/7 चलता है और मांग के साथ स्केल होता है, LiveKit Cloud आपके एजेंट को उनके इन्फ्रास्ट्रक्चर पर होस्ट करता है।

डिप्लॉयमेंट के लिए सेटअप

LiveKit CLI आपकी परियोजना का प्रकार डिपेंडेंसी फ़ाइलों के माध्यम से पहचानता है। अपने एजेंट डायरेक्टरी में एक requirements.txt बनाएं:

livekit-agents[xai,openai]>=1.3.10
python-dotenv>=1.2.1
firecrawl-py>=4.12.0

प्रोडक्शन सीक्रेट्स के लिए अलग फ़ाइल बनाएं। LiveKit Cloud स्वतः LIVEKIT_URL, LIVEKIT_API_KEY, और LIVEKIT_API_SECRET प्रदान करता है, इसलिए आपको केवल अन्य API keys शामिल करनी हैं:

XAI_API_KEY=xai-your-key-here
FIRECRAWL_API_KEY=fc-your-key-here

इसे .env.production के रूप में सहेजें और .gitignore में जोड़ें।

एजेंट को डिप्लॉय करना

CLI को अपने LiveKit Cloud खाते के साथ ऑथेंटिकेट करें:

lk cloud auth

यह आपके CLI को आपकी परियोजना से लिंक करने के लिए एक ब्राउज़र खोलता है। ऑथेंटिकेट होने के बाद, एजेंट डिप्लॉय करें:

lk agent create --secrets-file .env.production

CLI आपके एजेंट को रजिस्टर करता है, एक Dockerfile जनरेट करता है, कंटेनर इमेज बनाता है, और उसे LiveKit Cloud पर डिप्लॉय करता है। एजेंट के शुरू होते ही लॉग्स आपके टर्मिनल पर स्ट्रीम होते हैं:

{"message": "registered worker", "level": "INFO", "name": "livekit.agents", "url": "https://your-project.livekit.cloud", "region": "Germany 2", ...}

डिप्लॉयमेंट स्थिति जाँचें:

lk agent status

┌─────────────────┬─────────────────┬────────────┬─────────┬────────┬─────────┬───────────┐
 │ ID          	│ Version     	│ Region 	│ Status  │ CPU	│ Mem 	│ Replicas  │
 ├─────────────────┼─────────────────┼────────────┼─────────┼────────┼─────────┼───────────┤
 │ CA_AAVy5WbUYpmA │ v20260109102531 │ eu-central │ Running │ 0m / 2 │ 0 / 4GB │ 0 / 1 / 1 │
 └─────────────────┴─────────────────┴────────────┴─────────┴────────┴─────────┴───────────┘

उपयोगकर्ता आपके एजेंट तक कैसे पहुँचते हैं

डिप्लॉयमेंट लॉग्स में URL (https://your-project.livekit.cloud) WebSocket बैकएंड है, उपयोगकर्ता इंटरफ़ेस नहीं। उपयोगकर्ता इस बैकएंड से कनेक्ट होने वाले फ्रंटएंड के माध्यम से आपके एजेंट के साथ इंटरैक्ट करते हैं।

जो सैंडबॉक्स आपने पहले बनाया था, वह इसी उद्देश्य की पूर्ति करता है। अपने LiveKit डैशबोर्ड पर जाएँ, Sandbox सेक्शन खोलें, और अपना सैंडबॉक्स URL कॉपी करें। यह URL सार्वजनिक रूप से सुलभ है और किसी ऑथेंटिकेशन के बिना काम करता है। इसे उपयोगकर्ताओं के साथ साझा करें और वे तुरंत आपके एजेंट से बात करना शुरू कर सकते हैं।

ब्रांडेड अनुभव के लिए, डैशबोर्ड में सैंडबॉक्स का स्वरूप कस्टमाइज़ करें (लोगो, रंग, बटन टेक्स्ट) या LiveKit का JavaScript SDK उपयोग करके अपना फ्रंटएंड बनाएं।

डिप्लॉयमेंट प्रबंधन

अपने डिप्लॉय किए गए एजेंट से रियल-टाइम लॉग्स देखें:

lk agent logs

कोड में बदलाव के बाद अपडेट्स डिप्लॉय करें:

lk agent deploy --secrets-file .env.production

LiveKit रोलिंग डिप्लॉयमेंट्स का उपयोग करता है। नए इंस्टैंसेज़ नई सेशंस को संभालते हैं जबकि मौजूदा इंस्टैंसेज़ अपनी सक्रिय बातचीत पूरी करते हैं, इसलिए अपडेट्स से कोई डाउनटाइम नहीं होता।

यदि कुछ टूट जाए, तो पिछले वर्ज़न पर वापस लौटें:

lk agent rollback

डिप्लॉय किया गया एजेंट आपकी लोकल मशीन से स्वतंत्र रूप से चलता है। अपना टर्मिनल बंद करें, कंप्यूटर शटडाउन करें, एजेंट उपयोगकर्ताओं को जवाब देता रहेगा। LiveKit Cloud स्केलिंग संभालता है, इसलिए ट्रैफ़िक स्पाइक्स अपने आप अतिरिक्त इंस्टैंसेज़ स्पिन-अप कर देते हैं।

डिप्लॉयमेंट लागत

प्रोडक्शन में Grok वॉइस एजेंट चलाने में दो तरह की लागतें शामिल हैं: xAI का API और LiveKit की होस्टिंग।

xAI वॉइस बातचीत के प्रति मिनट $0.05 चार्ज करता है। LiveKit Cloud एजेंट सेशन समय के प्रति मिनट $0.01 जोड़ता है। दोनों मिलाकर, सक्रिय बातचीत के दौरान लगभग $0.06 प्रति मिनट अपेक्षित है।

LiveKit का फ्री टियर (Build प्लान) प्रति माह 1,000 एजेंट सेशन मिनट्स शामिल करता है, किसी क्रेडिट कार्ड की आवश्यकता नहीं। यह लगभग 16 घंटे की बातचीत कवर करता है, जो परीक्षण और कम-ट्रैफ़िक एप्लिकेशनों के लिए पर्याप्त है। पेड प्लान $50/माह से शुरू होते हैं, 5,000 शामिल मिनट्स और उच्च समवर्ती सीमाओं के साथ।

एजेंट के निष्क्रिय रहने पर कोई लागत नहीं लगती। शुल्क केवल सक्रिय बातचीत के दौरान लागू होते हैं, इसलिए रात भर निष्क्रिय डिप्लॉयमेंट पर कोई LiveKit फीस नहीं लगती। xAI बिलिंग भी इसी पैटर्न का पालन करती है, केवल वास्तविक API उपयोग को मीटर करती है। इस लेख को लिखते समय किए गए मेरे प्रयोगों में, मेरा कुल xAI खर्च 78 सेंट रहा, जबकि LiveKit फ्री टियर में कवर था।

निष्कर्ष

अब आपके पास एक वॉइस एजेंट है जो सुनता है, सोचता है और जवाब देता है। एजेंट टूल्स के माध्यम से लाइव डेटा से जुड़ता है, अलग-अलग वातावरणों के लिए अपनी सुनने की आदतों को समायोजित करता है, और ऐसे इन्फ्रास्ट्रक्चर पर चलता है जो बिना मैन्युअल हस्तक्षेप के स्केल होता है।

यहाँ कवर किए गए कोड पैटर्न अन्य उपयोग मामलों में भी लागू होते हैं। रिसर्च असिस्टेंट निर्देशों को ग्राहक सहायता दिशानिर्देशों से बदलें और ऐसे टूल्स जोड़ें जो आपके ऑर्डर डेटाबेस को क्वेरी करें। उदाहरण वाक्यों की खोज करने वाला एक भाषा ट्यूटर बनाएं। अपने मौजूदा API के लिए एक वॉइस इंटरफ़ेस तैयार करें।

xAI स्टैंडअलोन टेक्स्ट-टू-स्पीच और स्पीच-टू-टेक्स्ट एंडपॉइंट्स जारी करने की योजना बना रहा है, जो हाइब्रिड आर्किटेक्चर के लिए रास्ता खोलेंगे जहाँ आप Grok की वॉइस क्षमताओं को अन्य भाषा मॉडलों के साथ मिला सकते हैं। फिलहाल, वॉइस एजेंट API पूरी पाइपलाइन संभालता है।

LiveKit Agents दस्तावेज़ अतिरिक्त फीचर्स जैसे मल्टी-एजेंट हैंडऑफ़ और सेशन पर्सिस्टेंस को कवर करता है। xAI डॉक ऑडियो फ़ॉर्मैट्स और एंटरप्राइज़ फीचर्स पर और गहराई से जाती है।