livekit-plugins-smallestai पैकेज अब लाइव है। Pulse STT और Lightning TTS LiveKit Agents में प्रथम श्रेणी के प्लगइन्स हैं, जो बिना किसी कस्टम एडेप्टर या इंटीग्रेशन ओवरहेड के आपकी वॉयस पाइपलाइन में रीयल-टाइम स्पीच-टू-टेक्स्ट और अल्ट्रा-लो-लेटेंसी सिंथेसिस लाते हैं।

एक पैकेज। दोनों सेवाएं। पहले दिन से ही प्रोडक्शन-रेडी।

LiveKit Agents क्या है?

LiveKit Agents WebRTC पर प्रोडक्शन-ग्रेड, रीयल-टाइम वॉयस एआई एजेंट बनाने के लिए एक ओपन-सोर्स पायथन फ्रेमवर्क है। यदि आपने वॉयस एजेंट परिदृश्य को देखा है और अधिकांश विकल्पों को या तो बहुत अधिक ओपिनियनेटेड या बहुत लो-लेवल पाया है, तो LiveKit वास्तव में एक उपयोगी मध्यम मार्ग पर बैठता है — यह आपको हर हिस्से को निर्देशित किए बिना एक रीयल-टाइम वॉयस पाइपलाइन के बिल्डिंग ब्लॉक्स देता है।

इसका प्लगइन आर्किटेक्चर ही इसे निर्माण के योग्य बनाता है। STT, TTS, LLM, VAD — प्रत्येक एक स्वैपेबल घटक है। आप अपनी पसंद की सेवाओं को चुनते हैं, उन्हें एक AgentSession में जोड़ते हैं, और फ्रेमवर्क बाकी काम संभाल लेता है। टर्न्स, रुकावटें, WebRTC पर ऑडियो ट्रांसपोर्ट — सब कुछ संभाल लिया जाता है।

हमने क्या शिप किया

livekit-plugins-smallestai पैकेज PyPI पर लाइव है। यह आपको दो सेवाएं देता है:

smallestai.STT — Pulse द्वारा संचालित, हमारा रीयल-टाइम स्पीच-टू-टेक्स्ट इंजन। ~64ms TTFT के साथ WebSocket पर स्ट्रीम करता है, स्वचालित पहचान, वर्ड-लेवल टाइमस्टैम्प और स्पीकर डायराइजेशन के साथ 39 भाषाओं का समर्थन करता है।

smallestai.TTS — Lightning v3.1 द्वारा संचालित, हमारा अल्ट्रा-लो-लेटेंसी TTS इंजन। ~100ms लेटेंसी, 80+ आवाजें, और आपकी पाइपलाइन को जिस भी फॉर्मेट में आवश्यकता हो, उसमें आउटपुट।

दोनों सीधे LiveKit के प्लगइन सिस्टम में प्लग होते हैं। वे बिल्कुल किसी अन्य LiveKit प्लगइन की तरह व्यवहार करते हैं — जिसका अर्थ है कि इकोसिस्टम का हर हिस्सा जो LiveKit के साथ काम करता है, इनके साथ भी काम करता है।

यह कैसे काम करता है

इंस्टॉल करें

bash

अपना एनवायरनमेंट सेट अप करें

LIVEKIT_API_KEY=...
LIVEKIT_API_SECRET=...
LIVEKIT_URL=...
OPENAI_API_KEY=...
SMALLEST_API_KEY=...

LIVEKIT_API_KEY=...
LIVEKIT_API_SECRET=...
LIVEKIT_URL=...
OPENAI_API_KEY=...
SMALLEST_API_KEY=...

LIVEKIT_API_KEY=...
LIVEKIT_API_SECRET=...
LIVEKIT_URL=...
OPENAI_API_KEY=...
SMALLEST_API_KEY=...

STT- Pulse, WebSocket पर स्ट्रीमिंग

python

from livekit.plugins import smallestai

# English, streaming
stt = smallestai.STT(language="en")

# Automatic detection across 39 languages
stt = smallestai.STT(language="multi")

# With speaker diarization
stt = smallestai.STT(language="en", diarize=True)

from livekit.plugins import smallestai

# English, streaming
stt = smallestai.STT(language="en")

# Automatic detection across 39 languages
stt = smallestai.STT(language="multi")

# With speaker diarization
stt = smallestai.STT(language="en", diarize=True)

from livekit.plugins import smallestai

# English, streaming
stt = smallestai.STT(language="en")

# Automatic detection across 39 languages
stt = smallestai.STT(language="multi")

# With speaker diarization
stt = smallestai.STT(language="en", diarize=True)

Pulse रीयल-टाइम स्ट्रीमिंग के लिए हमारे WebSocket एंडपॉइंट से जुड़ता है, जिसमें अंतरिम और अंतिम ट्रांसक्रिप्ट के लिए पूर्ण समर्थन है। वर्ड-लेवल टाइमस्टैम्प और कॉन्फिडेंस स्कोर इसमें शामिल हैं।

TTS- Lightning, सेंटेंस-स्ट्रीम

python

from livekit.agents import tts, tokenize
from livekit.plugins import smallestai

smallest_tts = tts.StreamAdapter(
    tts=smallestai.TTS(
        model="lightning-v3.1",
        voice_id="sophia",
        language="en",
        speed=1.0,
    ),
    sentence_tokenizer=tokenize.basic.SentenceTokenizer(),
)

from livekit.agents import tts, tokenize
from livekit.plugins import smallestai

smallest_tts = tts.StreamAdapter(
    tts=smallestai.TTS(
        model="lightning-v3.1",
        voice_id="sophia",
        language="en",
        speed=1.0,
    ),
    sentence_tokenizer=tokenize.basic.SentenceTokenizer(),
)

from livekit.agents import tts, tokenize
from livekit.plugins import smallestai

smallest_tts = tts.StreamAdapter(
    tts=smallestai.TTS(
        model="lightning-v3.1",
        voice_id="sophia",
        language="en",
        speed=1.0,
    ),
    sentence_tokenizer=tokenize.basic.SentenceTokenizer(),
)

एक बात जानने योग्य है: Lightning प्रति टोकन के बजाय प्रति अनुरोध ऑडियो सिंथेसाइज करता है, इसलिए इसे SentenceTokenizer के साथ LiveKit के StreamAdapter में लपेटना सही कदम है। एडेप्टर वाक्य सीमाओं पर LLM आउटपुट को विभाजित करता है और प्रत्येक टुकड़े के लिए सिंथेसिस शुरू करता है — जिससे एक शब्द बजने से पहले पूरे LLM प्रतिक्रिया के पूरा होने की प्रतीक्षा किए बिना पहले-ऑडियो की लेटेंसी कम रहती है।

एक फ़ाइल में एक पूरा एजेंट

STT और TTS दोनों के लिए Smallest AI का उपयोग करने वाला एक पूर्ण, प्रोडक्शन-रेडी वॉयस एजेंट यहां दिया गया है:

python

import logging
from dotenv import load_dotenv
from livekit.agents import (
    Agent, AgentSession, JobContext, JobProcess,
    RoomInputOptions, RoomOutputOptions, WorkerOptions, cli, tts, tokenize,
)
from livekit.plugins import openai, silero, smallestai

logger = logging.getLogger("voice-agent")
load_dotenv()

class MyAgent(Agent):
    def __init__(self) -> None:
        super().__init__(
            instructions="You are a helpful voice assistant built by Smallest AI.",
        )

    async def on_enter(self):
        self.session.generate_reply()

def prewarm(proc: JobProcess):
    proc.userdata["vad"] = silero.VAD.load()

async def entrypoint(ctx: JobContext):
    session = AgentSession(
        vad=ctx.proc.userdata["vad"],
        stt=smallestai.STT(language="en"),
        llm=openai.LLM(model="gpt-4o-mini"),
        tts=tts.StreamAdapter(
            tts=smallestai.TTS(),
            sentence_tokenizer=tokenize.basic.SentenceTokenizer(),
        ),
    )
    await session.start(
        agent=MyAgent(),
        room=ctx.room,
        room_input_options=RoomInputOptions(),
        room_output_options=RoomOutputOptions(transcription_enabled=True),
    )

if __name__ == "__main__":
    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint, prewarm_fnc=prewarm))

import logging
from dotenv import load_dotenv
from livekit.agents import (
    Agent, AgentSession, JobContext, JobProcess,
    RoomInputOptions, RoomOutputOptions, WorkerOptions, cli, tts, tokenize,
)
from livekit.plugins import openai, silero, smallestai

logger = logging.getLogger("voice-agent")
load_dotenv()

class MyAgent(Agent):
    def __init__(self) -> None:
        super().__init__(
            instructions="You are a helpful voice assistant built by Smallest AI.",
        )

    async def on_enter(self):
        self.session.generate_reply()

def prewarm(proc: JobProcess):
    proc.userdata["vad"] = silero.VAD.load()

async def entrypoint(ctx: JobContext):
    session = AgentSession(
        vad=ctx.proc.userdata["vad"],
        stt=smallestai.STT(language="en"),
        llm=openai.LLM(model="gpt-4o-mini"),
        tts=tts.StreamAdapter(
            tts=smallestai.TTS(),
            sentence_tokenizer=tokenize.basic.SentenceTokenizer(),
        ),
    )
    await session.start(
        agent=MyAgent(),
        room=ctx.room,
        room_input_options=RoomInputOptions(),
        room_output_options=RoomOutputOptions(transcription_enabled=True),
    )

if __name__ == "__main__":
    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint, prewarm_fnc=prewarm))

import logging
from dotenv import load_dotenv
from livekit.agents import (
    Agent, AgentSession, JobContext, JobProcess,
    RoomInputOptions, RoomOutputOptions, WorkerOptions, cli, tts, tokenize,
)
from livekit.plugins import openai, silero, smallestai

logger = logging.getLogger("voice-agent")
load_dotenv()

class MyAgent(Agent):
    def __init__(self) -> None:
        super().__init__(
            instructions="You are a helpful voice assistant built by Smallest AI.",
        )

    async def on_enter(self):
        self.session.generate_reply()

def prewarm(proc: JobProcess):
    proc.userdata["vad"] = silero.VAD.load()

async def entrypoint(ctx: JobContext):
    session = AgentSession(
        vad=ctx.proc.userdata["vad"],
        stt=smallestai.STT(language="en"),
        llm=openai.LLM(model="gpt-4o-mini"),
        tts=tts.StreamAdapter(
            tts=smallestai.TTS(),
            sentence_tokenizer=tokenize.basic.SentenceTokenizer(),
        ),
    )
    await session.start(
        agent=MyAgent(),
        room=ctx.room,
        room_input_options=RoomInputOptions(),
        room_output_options=RoomOutputOptions(transcription_enabled=True),
    )

if __name__ == "__main__":
    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint, prewarm_fnc=prewarm))

इसे चलाएं:

bash

LiveKit Agents Playground खोलें, अपने LiveKit क्रेडेंशियल दर्ज करें, और सेशन शुरू होते ही आपका एजेंट तुरंत आपका स्वागत करेगा।

यहाँ एक ऐसा परिदृश्य है जिससे आप शायद गुज़रे होंगे।

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

यह कोई मामूली बाहरी मामला नहीं है। यह वही चीज़ है जो एक वॉयस बॉट को वॉयस कन्वर्सेशन (बातचीत) से अलग करती है। और इसे सही करना वास्तव में कठिन है — इसलिए नहीं कि अवधारणा जटिल है, बल्कि इसलिए कि रीयल-टाइम ऑडियो क्षमा नहीं करता है। उपयोगकर्ता द्वारा बोलना शुरू करने और पाइपलाइन द्वारा उस पर प्रतिक्रिया देने के बीच किसी भी देरी को तुरंत महसूस किया जाता है। इसे छिपाने का कोई तरीका नहीं है।

LiveKit इसे Silero VAD का उपयोग करके फ्रेमवर्क स्तर पर संभालता है — निरंतर वॉयस एक्टिविटी डिटेक्शन जो आपकी पाइपलाइन के साथ चलता है और भाषण का पता चलते ही रुकावट की घटना (interruption event) को सक्रिय करता है। ऑडियो तुरंत रुक जाता है। एजेंट फिर से जुड़ जाता है। बातचीत बिना किसी रुकावट के जारी रहती है।

एक विवरण जिसे ध्यान में रखना उचित है: eou_timeout_ms को इसके डिफॉल्ट 0 पर छोड़ दें। यह Pulse की तरफ सर्वर-साइड एंड-ऑफ-अटरेंस डिटेक्शन को अक्षम करता है और LiveKit के अपने टर्न डिटेक्शन को समय संभालने देता है। दोनों को एक साथ जोड़ने से आप अनावश्यक लेटेंसी जोड़ रहे होते हैं जिसकी आपको प्रत्येक टर्न के अंत में आवश्यकता नहीं होती है।

यह इंटीग्रेशन क्यों मौजूद है

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

Pulse 64ms TTFT पर ट्रांसक्रिप्शन प्रदान करता है। Lightning ~100ms में ऑडियो को सिंथेसाइज और स्ट्रीम करता है। ये केवल बेंचमार्क नंबर नहीं हैं — ये लेटेंसी थ्रेसहोल्ड हैं जो वॉयस कन्वर्सेशन को मैकेनिकल के बजाय नेचुरल महसूस कराते हैं। LiveKit उन्हें प्रोडक्शन में सुरक्षित रूप से चलाने के लिए WebRTC ट्रांसपोर्ट और टर्न-डिटेक्शन इंफ्रास्ट्रक्चर प्रदान करता है।

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

शुरू करें

दस्तावेज़ → docs.smallest.ai

पूर्ण उदाहरण → Smallest AI × LiveKit कुकबुक

PyPI → livekit-plugins-smallestai

प्रश्न? हमें Discord पर खोजें या कुकबुक रेपो में एक समस्या (issue) दर्ज करें।

Smallest AI इंटरनेट पर सबसे तेज़ स्पीच इंफ्रास्ट्रक्चर बनाता है। Lightning TTS और Pulse STT आज API के माध्यम से उपलब्ध हैं।