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

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

LiveKit Agents क्या है?

LiveKit Agents WebRTC पर प्रोडक्शन-ग्रेड, रीयल-टाइम वॉयस AI एजेंट्स बनाने के लिए एक ओपन-सोर्स पायथन फ्रेमवर्क है। यदि आपने वॉयस एजेंट परिदृश्य को देखा है और अधिकांश विकल्पों को बहुत अधिक ओपिनियनेटेड या बहुत कम-स्तर का पाया है, तो 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 का उपयोग करके फ्रेमवर्क स्तर पर संभालता है — निरंतर वॉयस एक्टिविटी डिटेक्शन जो आपकी पाइपलाइन के साथ चलता है और जैसे ही भाषण का पता चलता है, एक व्यवधान इवेंट ट्रिगर करता है। ऑडियो तुरंत रुक जाता है। एजेंट फिर से संलग्न होता है। बातचीत बिना किसी रुकावट के जारी रहती है।

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

यह एकीकरण क्यों मौजूद है

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

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

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

शुरू करें

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

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

PyPI → livekit-plugins-smallestai

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

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