Mistral का Voxtral: डेमो प्रोजेक्ट सहित गाइड

Mistral ने हाल ही में अपने पहले ओपन‑सोर्स मल्टीमॉडल ऑडियो मॉडल—Voxtral Small और Voxtral Mini—लॉन्च किए हैं, जो Mistral 3B आर्किटेक्चर पर आधारित हैं और ऑडियो अंडरस्टैंडिंग व ट्रांसक्रिप्शन कार्यों के लिए विशेष रूप से ऑप्टिमाइज़ किए गए हैं।

इस ब्लॉग में मेरा फोकस Voxtral Mini 3B पर होगा—एक कॉम्पैक्ट, ओपन‑सोर्स मॉडल जो रीयल‑टाइम ऑडियो‑टू‑टेक्स्ट कार्यों जैसे ट्रांसक्रिप्शन, सारांश और Q&A के लिए बनाया गया है। अपने कुशल आकार और लॉन्ग‑कॉन्टेक्स्ट रीजनिंग सपोर्ट के साथ, Voxtral Mini उच्च थ्रूपुट इन्फ़रेंस फ़्रेमवर्क जैसे vLLM के साथ पेयर करने पर विशेष रूप से शक्तिशाली है, जिससे यह तेज़, ऑफ़लाइन ऑडियो एप्लिकेशनों के लिए आदर्श बनता है।

इस ट्यूटोरियल में, मैं आपको बताऊँगा कि कैसे:

• Colab Pro पर vLLM के साथ Voxtral Mini 3B चलाएँ
• ngrok‑टनेल्ड API एंडपॉइंट डिप्लॉय करें ताकि आप अपने मॉडल को कहीं से भी एक्सेस कर सकें
• Streamlit‑आधारित ऑडियो असिस्टेंट बनाएँ जो रॉ ऑडियो इनपुट से ट्रांसक्रिप्शन, सारांश और Q&A करता है

हम अपने पाठकों को नवीनतम AI अपडेट्स The Median—हमारे मुफ़्त शुक्रवार न्यूज़लेटर—के ज़रिए भेजते हैं, जो हफ्ते की प्रमुख खबरों का संक्षेप देता है। सब्सक्राइब करें और हर हफ्ते कुछ ही मिनटों में अपडेट रहें:

Mistral का Voxtral क्या है?

Voxtral, Mistral का पूरी तरह ओपन‑सोर्स ऑडियो मॉडल परिवार है जिसे शक्तिशाली स्पीच अंडरस्टैंडिंग के लिए डिज़ाइन किया गया है। Voxtral दो मॉडल आकारों में आता है:

• Voxtral Small: 24 B पैरामीटर्स, प्रोडक्शन‑स्तरीय, एंटरप्राइज़ उपयोग के लिए उपयुक्त
• Voxtral Mini: 3 B पैरामीटर्स, एज डिवाइसेज़ पर लोकली चलाने के लिए ऑप्टिमाइज़्ड

स्रोत: Mistral

Voxtral रॉ ऑडियो इनपुट्स (जैसे .wav या .mp3) स्वीकार करता है और बोले गए कंटेंट से ट्रांसक्रिप्शन व सारांश कुशलतापूर्वक जनरेट करने के लिए प्रशिक्षित है। Voxtral एक छोटा वैरिएंट है जो तेज़ इन्फ़रेंस और ऑफ़लाइन डिप्लॉयमेंट के लिए ऑप्टिमाइज़्ड है।

यह Mistral के मॉडल फॉरमैट का पालन करता है और vLLM जैसे उच्च‑थ्रूपुट इन्फ़रेंस फ़्रेमवर्क के साथ संगत है, जिससे यह रीयल‑टाइम ट्रांसक्रिप्शन या हल्के स्पीच एप्लिकेशनों के लिए उत्कृष्ट विकल्प बनता है।

vLLM का उपयोग करके Voxtral Mini 3B कैसे चलाएँ

इस सेक्शन में, मैं आपको दिखाऊँगा कि Colab Pro पर T4 GPU सक्षम करके vLLM के जरिए Voxtral Mini 3B कैसे सर्व करें। vLLM को इसके उच्च‑थ्रूपुट, कम‑लेटेंसी सर्विंग क्षमता के लिए चुना गया है, जो Voxtral जैसे मॉडलों के लिए आदर्श है जिन्हें ऑडियो सपोर्ट के साथ तेज़ स्ट्रीमिंग रिस्पॉन्स चाहिए।

साथ ही, हम PyNGrok का उपयोग करेंगे ताकि vLLM सर्वर को एक पब्लिक एंडपॉइंट के ज़रिए एक्सपोज़ किया जा सके, जिससे यह आपकी लोकल मशीन पर चल रहे एप्लिकेशनों के लिए भी एक्सेसिबल हो।

चरण 1: डिपेंडेंसी इंस्टॉल करें

आइए Colab एनवायरनमेंट में डिपेंडेंसियाँ इंस्टॉल करके शुरू करें। Colab सेल में निम्न कमांड चलाएँ:

!uv pip install -U transformers accelerate "vllm[audio]" --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightlyसंचालित द्वारा

हम uv—एक तेज़ Python पैकेज इंस्टॉलर—का उपयोग करके आवश्यक लाइब्रेरियाँ इंस्टॉल करना शुरू करते हैं। यह vllm[audio] का नाइटली वर्ज़न लाता है, जिसमें Voxtral जैसे ऑडियो‑लैंग्वेज मॉडलों के लिए एक्सपेरिमेंटल सपोर्ट शामिल है। यदि आपके एनवायरनमेंट में uv इंस्टॉल नहीं है, तो पहले निम्न कोड चलाकर uv इंस्टॉल करें:

!pip install uvसंचालित द्वारा

चरण 2: Mistral-Common इंस्टॉल करें

अब हम mistral-common पैकेज इंस्टॉल करते हैं, जो Voxtral और अन्य Mistral‑परिवार के मॉडलों के साथ इंटरैक्ट करने के लिए आवश्यक यूटिलिटीज़ देता है। इस पैकेज में आधिकारिक इम्प्लीमेंटेशन्स के अनुरूप टोकनाइज़र और मैसेज स्ट्रक्चर्स के लिए Pydantic‑आधारित वेलिडेशन शामिल है।

!pip install mistral-common --upgrade
!python -c "import mistral_common; print(mistral_common.__version__)"संचालित द्वारा

mistral-common पैकेज में Voxtral और अन्य Mistral फैमिली मॉडलों के लिए यूटिलिटी मॉड्यूल शामिल हैं। इसमें टोकनाइज़र, Pydantic फ़ॉर्मैट्स में टाइप्ड मैसेज, और ऑडियो हेल्पर फ़ंक्शंस शामिल हैं। यह चरण Voxtral के ऑडियो इनपुट्स और स्ट्रक्चर्ड मैसेज की इंटरनल हैंडलिंग के साथ कम्पैटिबिलिटी सुनिश्चित करता है।

चरण 3: VLLM सेटअप करें

अब जब बेसिक Mistral डिपेंडेंसियाँ तैयार हैं, तो अगला कदम vLLM को उसकी मेन रिपॉज़िटरी क्लोन करके सेटअप करना है।

चरण 3.1: vLLM रिपॉज़िटरी क्लोन करें

हम आधिकारिक vLLM GitHub रिपॉज़िटरी क्लोन करते हैं, जिससे हमें बिल्ट‑इन ऑडियो उदाहरणों तक पहुँच मिलती है और ऑफ़लाइन या होस्टेड इन्फ़रेंस लॉन्च करने के लिए बेस मिलता है।

!git clone https://github.com/vllm-project/vllm && cd vllmसंचालित द्वारा

चरण 3.2: एक सैंपल ऑडियो इन्फ़रेंस चलाएँ 

आइए एक त्वरित सैनेटिटी चेक चलाएँ ताकि सेटअप सही होने की पुष्टि हो सके।

!python vllm/examples/offline_inference/audio_language.py --num-audios 2 --model-type voxtralसंचालित द्वारा

मैंने ऑफ़लाइन audio_language.py उदाहरण चलाया, जो Voxtral मॉडल का उपयोग करके दो पूर्व‑परिभाषित सैंपल्स पर ऑडियो‑लैंग्वेज इन्फ़रेंस चलाता है और जाँचता है कि ऑडियो डिकोडिंग और जनरेशन सही से काम कर रहे हैं या नहीं।

चरण 4: PyGrok सेटअप करें

vLLM सेटअप हो जाने के बाद, आइए PyNGrok कॉन्फ़िगर करें ताकि Colab पर vLLM सर्वर को एक सार्वजनिक रूप से एक्सेसिबल इंटरनेट एड्रेस के माध्यम से एक्सपोज़ किया जा सके।

• https://ngrok.com/ पर एक मुफ़्त अकाउंट बनाकर शुरू करें
• Connect टैब के अंतर्गत नीचे स्क्रॉल करें, ऑथेंटिकेशन टैग (नीचे की इमेज में छिपा हुआ) कॉपी करें और उसे Colab Secrets में एक सीक्रेट के रूप में सेव करें।

इसके बाद, हम Colab एनवायरनमेंट में PyNGrok इंस्टॉल करते हैं और पहले कॉपी किए गए NGROK टोकन का उपयोग करके ऑथेंटिकेशन टोकन सेट करते हैं। यदि आप प्रोटोटाइप पर काम कर रहे हैं, तो आप टोकन सीधे यहाँ पास कर सकते हैं।

!pip install pyngrok -q
from pyngrok import ngrok
ngrok.set_auth_token("NGROK_TOKEN")संचालित द्वारा

चरण 5: मॉडल सर्व करें

यह मुख्य चरण है, जहाँ हम vLLM के माध्यम से Voxtral Mini 3B मॉडल लॉन्च करते हैं। 

!vllm serve mistralai/Voxtral-Mini-3B-2507 --tokenizer_mode mistral --config_format mistral --load_format mistral --max-model-len 4864संचालित द्वारा

इस कोड स्निपेट में कुछ महत्वपूर्ण फ़्लैग शामिल हैं:

• --tokenizer_mode mistral: यह सटीक टोकनाइज़ेशन के लिए Mistral‑विशिष्ट टोकनाइज़र का उपयोग करता है।
• --config_format mistral और --load_format mistral: ये फ़्लैग सुनिश्चित करते हैं कि मॉडल कॉन्फ़िगरेशन और वेट्स दोनों Mistral के कस्टम फॉरमैट में लोड हों, जिससे कम्पैटिबिलिटी बनी रहे।
• --max-model-len 4864: यह फ़्लैग अधिकतम इनपुट कॉन्टेक्स्ट लंबाई 4864 टोकन सेट करता है।

नोट: इसे एक्टिव मॉडल सर्वर होने के कारण इस सेल को चलने दें।

चरण 6: NGrok पब्लिक एंडपॉइंट प्राप्त करें

जब आपका vLLM सर्वर चल रहा हो, तो Python टर्मिनल में निम्न कोड लाइन‑दर‑लाइन चलाएँ:

from pyngrok import ngrok
ngrok.set_auth_token(NGROK_TOKEN)
public_url = ngrok.connect(8000)
print("Public endpoint:", public_url)संचालित द्वारा

ऊपर दिया गया कोड मॉडल को इंटरनेट पर एक अस्थायी पब्लिक URL पर एक्सपोज़ करेगा, जैसे:

https://80xxxxxxxxxx.ngrok-free.appसंचालित द्वारा

इस URL को सेव कर लें—इसे लोकल config.py में रिमोट मॉडल से कनेक्ट करने के लिए उपयोग किया जाएगा। रन पूरा होने के बाद, निम्न चलाकर कनेक्शन समाप्त करें:

ngrok.kill()संचालित द्वारा

ऑडियो ट्रांसक्रिप्शन और सारांश डेमो बनाना

इस सेक्शन में, हम एक Streamlit UI बनाएँगे जो:

1. इनपुट के रूप में ऑडियो लेता है (यूज़र अपलोड)
2. उसे vLLM सर्वर के ज़रिए मॉडल को भेजता है
3. ट्रांसक्रिप्शन, सारांश दिखाता है और यूज़र को प्रश्न पूछने देता है

चरण 1: डिपेंडेंसियाँ सेट करना

ऐप बनाने से पहले, हम सभी आवश्यक डिपेंडेंसियों को requirements.txt फ़ाइल में परिभाषित करते हैं। यह लोकल रन या Colab नोटबुक्स में समान एनवायरनमेंट सुनिश्चित करता है।

streamlit>=1.28.0
openai>=1.0.0
mistral-common>=0.0.12
huggingface-hub>=0.19.0
pyngrok>=6.0.0
requests>=2.28.0
pydub>=0.25.1 संचालित द्वारा

हमें इनकी ज़रूरत क्यों है:

• streamlit: इंटरैक्टिव ऑडियो इंटरफ़ेस बनाने में मदद करता है।
• openai: OpenAI के SDK का उपयोग करके Voxtral‑कम्पैटिबल vLLM सर्वर से इंटरफ़ेस करता है।
• mistral-common: AudioChunk और TextChunk जैसे Voxtral‑विशिष्ट यूटिलिटीज़ देता है।
• pyngrok: हमारे लोकल vLLM सर्वर को इंटरनेट पर एक्सपोज़ करता है, जिससे Streamlit ऐप उसे एक्सेस कर सके।
• Pydub: इन्फ़रेंस के लिए ऑडियो फ़ाइलों को कन्वर्ट करने में मदद करता है।
• huggingface-hub और requests: मॉडल और कॉन्फ़िग फ़ेचिंग (यदि ज़रूरत हो) के लिए।

चरण 2: एनवायरनमेंट वेरिएबल सेट करना

कॉनफ़िगरेशन को साफ़ और पोर्टेबल रखने के लिए, हम API डीटेल्स को एनवायरनमेंट वेरिएबल्स के रूप में स्टोर करते हैं। आप इन्हें .env फ़ाइल के अंदर परिभाषित कर सकते हैं:

VOXTRAL_API_KEY=dummy-key
VOXTRAL_API_BASE=NGROK_TOKEN/v1
VOXTRAL_MODEL_NAME=mistralai/Voxtral-Mini-3B-2507संचालित द्वारा

VOXTRAL_API_BASE को आपके रनिंग vLLM इंस्टेंस की ओर पॉइंट करना चाहिए, जो localhost (http://localhost:8000) या एक ngrok पब्लिक एंडपॉइंट (जैसे https://80xxxxxxxxxx.ngrok-free.app) हो सकता है।

नोट: OpenAI कम्पैटिबिलिटी के लिए API बेस के अंत में /v1 जोड़ना सुनिश्चित करें।

चरण 3: कॉन्फ़िग फ़ाइल सेट करना

अपने ऐप को मॉड्यूलर, आसानी से समायोज्य और प्रोडक्शन‑तैयार बनाने के लिए, हम config.py में एक केंद्रीय कॉन्फ़िगरेशन क्लास परिभाषित करेंगे। यह फ़ाइल मॉडल सेटिंग्स, API एक्सेस, सपोर्टेड ऑडियो फ़ॉर्मैट्स, भाषाएँ और UI प्रेफ़रेंसेज़ को नियंत्रित करेगी।

चरण 3.1: एनवायरनमेंट वेरिएबल लोड करें

कॉन्फ़िग क्लास परिभाषित करने से पहले, हम .env फ़ाइल में सेव किसी भी एनवायरनमेंट वेरिएबल को लोड करते हैं। यह संवेदनशील जानकारी को कोड से अलग रखता है।

import os
from typing import Optional
from pathlib import Path
# Load environment variables from .env file
env_file = Path(".env")
if env_file.exists():
    with open(env_file, 'r') as f:
        for line in f:
            if line.strip() and not line.startswith('#'):
                key, value = line.strip().split('=', 1)
                os.environ[key] = valueसंचालित द्वारा

यह स्निपेट जाँचता है कि रूट डायरेक्टरी में .env फ़ाइल मौजूद है या नहीं। यदि मिलती है, तो यह की‑वैल्यू पेयर्स पढ़कर उन्हें एनवायरनमेंट वेरिएबल्स के रूप में सेट करता है। अब इन वैल्यूज़ को os.getenv() के जरिए एक्सेस किया जा सकता है, जिससे सीक्रेट्स कोड में हार्डकोड नहीं होते।

चरण 3.2: Config क्लास परिभाषित करें

अब, हम सभी सेटिंग्स को आसान एक्सेस और रीयूज़ के लिए एक साफ़ Config क्लास में रैप करते हैं।

class Config:
    # API Configuration
    VOXTRAL_API_KEY: str = os.getenv("VOXTRAL_API_KEY", "EMPTY")
    VOXTRAL_API_BASE: str = os.getenv("VOXTRAL_API_BASE", "http://localhost:8000/v1")
    # Model Configuration
    MODEL_NAME: str = os.getenv("VOXTRAL_MODEL_NAME", "voxtral-mini-3b-2507")
    # Default Parameters
    DEFAULT_TEMPERATURE: float = 0.2
    DEFAULT_TOP_P: float = 0.95
    # Audio Configuration
    MAX_AUDIO_SIZE_MB: int = 100
    SUPPORTED_AUDIO_FORMATS: list = ['mp3', 'wav', 'm4a', 'flac', 'ogg']
    SUPPORTED_LANGUAGES: list = [
        "English", "Spanish", "French", "German", "Italian", "Portuguese", 
        "Russian", "Chinese", "Japanese", "Korean", "Arabic", "Hindi"
    ]
    # UI Configuration
    STREAMLIT_THEME: dict = {
        "primaryColor": "#1f77b4",
        "backgroundColor": "#ffffff",
        "secondaryBackgroundColor": "#f0f2f6",
        "textColor": "#262730",
        "font": "sans serif"
    }
    @classmethod
    def get_api_config(cls) -> dict:
        return {
            "api_key": cls.VOXTRAL_API_KEY,
            "base_url": cls.VOXTRAL_API_BASE,
            "model_name": cls.MODEL_NAME
        }    
    @classmethod
    def validate_config(cls) -> bool:
        if not cls.VOXTRAL_API_BASE:
            return False
        return True    
    @classmethod
    def get_language_code(cls, language_name: str) -> Optional[str]:
        language_mapping = {
            "English": "en",
            "Spanish": "es", 
            "French": "fr",
            "German": "de",
            "Italian": "it",
            "Portuguese": "pt",
            "Russian": "ru",
            "Chinese": "zh",
            "Japanese": "ja",
            "Korean": "ko",
            "Arabic": "ar",
            "Hindi": "hi"
        }
        return language_mapping.get(language_name) संचालित द्वारा

एक साथ मिलकर, यह Config क्लास आपके Voxtral‑समर्थित ऐप के लिए केंद्रीकृत कंट्रोल हब का काम करता है। चाहे आप मॉडल पैरामीटर्स कॉन्फ़िगर कर रहे हों, ऑडियो फ़ॉर्मैट्स मैनेज कर रहे हों, या ऐप थीम सेट कर रहे हों—यह सेटअप क्लीन एब्स्ट्रैक्शन, कोड रीयूज़ेबिलिटी और मेंटेनबिलिटी सुनिश्चित करता है।

क्लास में शामिल हैं:

• get_api_config() मेथड: यह मेथड सभी API‑सम्बंधित क्रेडेंशियल्स को केंद्रीकृत करता है। जहाँ भी आपका ऐप Voxtral मॉडल को कॉल करता है, आप एक बार में सबकुछ पाने के लिए Config.get_api_config() का उपयोग कर सकते हैं।
• validate_config() मेथड: इन्फ़रेंस शुरू करने से पहले, यह मेथड जाँचता है कि आवश्यक कॉन्फ़िग वैल्यूज़ (जैसे बेस URL) ठीक से परिभाषित हैं या नहीं। यदि नहीं, तो आप समस्या जल्दी पकड़कर यूज़र को अलर्ट कर सकते हैं।
• get_language_code() मेथड: यह मेथड UI से यूज़र‑फ्रेंडली भाषा नामों (जैसे “French”) को मानकीकृत ISO भाषा कोड्स (जैसे “fr”) से मैप करता है, जिससे मल्टीलिंगुअल Q&A सहज हो जाता है। यदि असमर्थित भाषा पास होती है, तो यह सुरक्षित रूप से None लौटाता है।

चरण 4: Streamlit ऐप बनाएँ

आइए हर सब‑स्टेप के ज़रिए ऐप का इंटरफ़ेस और लॉजिक तैयार करें।

चरण 4.1: लेआउट और स्टाइलिंग सेट करें

इस चरण में, हम Streamlit फ्रंटएंड इनिशियलाइज़ करते हैं, डिपेंडेंसियाँ लोड करते हैं और CSS स्टाइल सेट करते हैं। यही ऐप की दृश्य और फ़ंक्शनल नींव बनाता है।

import streamlit as st
import tempfile
import os
from mistral_common.protocol.instruct.messages import TextChunk, AudioChunk, UserMessage
from mistral_common.audio import Audio
from openai import OpenAI
import time
from config import Config
# Page configuration
st.set_page_config(
    page_title="Voxtral Audio Assistant",
    page_icon="🎵",
    layout="wide",
    initial_sidebar_state="expanded"
)
# Custom CSS 
st.markdown("""
<style>
    .main-header {
        
        font-weight: bold;
        
        text-align: center;
        
    }
    .section-header {
        
        font-weight: bold;
        
        
    }
    .info-box {
        background-
        
        border-radius: 0.5rem;
        border-left: 4px solid #1f77b4;
        
    }
    .success-box {
        background-
        
        border-radius: 0.5rem;
        border-left: 4px solid #28a745;
        
    }
    .chat-message {
        
        border-radius: 0.5rem;
        
    }
    .user-message {
        background-
        border-left: 4px solid #2196f3;
    }
    .assistant-message {
        background-
        border-left: 4px solid #9c27b0;
    }
</style>
""", unsafe_allow_html=True)संचालित द्वारा

ऊपर दिए गए Python और CSS कोड में:

• हम UI, फ़ाइल हैंडलिंग और Voxtral के mistral_common पैकेज का उपयोग करके ऑडियो/टेक्स्ट मैसेज फॉर्मैटिंग के लिए आवश्यक लाइब्रेरियों को इम्पोर्ट करते हैं।
• इसके बाद, हम Streamlit ऐप का लेआउट कॉन्फ़िगर करते हैं—डुअल‑पेन इंटरफ़ेस और डिफ़ॉल्ट रूप से एक्सपैंडेड साइडबार।
• अंत में, हम कस्टम CSS इंजेक्ट करते हैं ताकि UI के अलग‑अलग हिस्सों—हेडर, ऑडियो सेक्शन, चैट बबल्स और सारांश बॉक्स—को दृश्य रूप से अलग किया जा सके। इससे ऐप की विज़ुअल हाइरार्की बेहतर होती है, टाइटल्स, इन्फ़ो मैसेज और यूज़र बनाम असिस्टेंट रिप्लाई के अलग‑अलग चैट बबल स्पष्ट होते हैं।

चरण 4.2: सेशन और क्लाइंट इनिशियलाइज़ करें

अगला, हम सेशन वेरिएबल्स और क्लाइंट इनिशियलाइज़ करके रीলোड्स के बीच ऐप के व्यवहार को सुसंगत रखते हैं।

def init_session_state():
    defaults = {
        'transcription': "",
        'summary': "",
        'chat_history': [],
        'audio_file_path': None
    }
    for key, default_value in defaults.items():
        if key not in st.session_state:
            st.session_state[key] = default_value
def initialize_client():
    config = Config.get_api_config() 
    client = OpenAI(
        api_key=config["api_key"],
        base_url=config["base_url"],
    ) 
    # Test connection
    try:
        models = client.models.list()
        return client
    except Exception as e:
        st.error(f"Failed to connect to Voxtral API: {str(e)}")
        st.info("Make sure your ngrok tunnel is running in Google Colab")
        return Noneसंचालित द्वारा

यह कोड स्निपेट ऐप की इंटरनल स्टेट सेट करता है और Voxtral API सर्वर से कनेक्शन हैंडल करता है। इसमें दो मुख्य घटक हैं:

1. सेशन इनिशियलाइज़ेशन: सुनिश्चित करता है कि ट्रांसक्रिप्शन, सारांश और अपलोडेड ऑडियो फ़ाइल जैसी यूज़र डेटा ऐप इंटरैक्शंस और रीलोड्स के दौरान सही से मौजूद रहें।
2. क्लाइंट इनिशियलाइज़ेशन: vLLM के जरिए एक्सपोज़ किए गए OpenAI‑कम्पैटिबल एंडपॉइंट से लोकली होस्ट किए गए Voxtral Mini 3B मॉडल से कनेक्ट करता है (Ngrok के ऊपर सर्व किया हुआ)। कनेक्शन फ़ेल होने पर UI में एरर मैसेज दिखाया जाता है।

चरण 4.3: ऑडियो चंकिंग और रीयल‑टाइम ट्रांसक्रिप्शन

यह चरण ऑडियो फ़ाइल तैयार करने और Voxtral Mini 3B का उपयोग करके ट्रांसक्रिप्शन जनरेट करने की कोर लॉजिक हैंडल करता है।

def file_to_chunk(file_path: str) -> AudioChunk:
    audio = Audio.from_file(file_path, strict=False)
    return AudioChunk.from_audio(audio)
def transcribe_audio(client, audio_file_path):
    try:
        with open(audio_file_path, "rb") as f:
            response = client.audio.transcriptions.create(
                file=f,
                model=Config.MODEL_NAME,
                response_format="text",
                stream=True
            )       
            transcription = ""
            progress_bar = st.progress(0)
            status_text = st.empty()
            # Collect all chunks first to get total count
            chunks = list(response)
            total_chunks = len(chunks)
            for i, chunk in enumerate(chunks):
                delta = chunk.choices[0].get("delta", {}).get("content")
                if delta:
                    transcription += delta
                    progress = min((i + 1) / max(total_chunks, 1), 1.0)
                    progress_bar.progress(progress)
                    status_text.text(f"Transcribing... {len(transcription)} characters")
            progress_bar.empty()
            status_text.empty()
            return transcription
    except Exception as e:
        st.error(f"Error during transcription: {str(e)}")
        return Noneसंचालित द्वारा

यहाँ दो प्रमुख फ़ंक्शंस हैं:

1. ऑडियो चंक कन्वर्ज़न: पहले, अपलोडेड ऑडियो फ़ाइल को AudioChunk फॉर्मैट में कन्वर्ट करते हैं, जो Voxtral की API के लिए आवश्यक इनपुट है।
2. प्रोग्रेस फीडबैक के साथ स्ट्रीमिंग ट्रांसक्रिप्शन: हम ऑडियो को स्ट्रीम्ड तरीके (stream=True) से मॉडल को भेजते हैं और चंक‑बाय‑चंक डिकोड करते हैं। जैसे‑जैसे टोकन्स मिलते हैं, प्रोग्रेस बार डायनमिक रूप से अपडेट होता है, जिससे यूज़र को रीयल‑टाइम ट्रांसक्रिप्शन प्रोग्रेस दिखती है।

चरण 4.4: ऑडियो से सारांश जनरेट करें

यह चरण ऑडियो इनपुट के साथ एक टेक्स्टुअल प्रॉम्प्ट Voxtral मॉडल को भेजता है, जो ऑडियो कंटेंट का संक्षिप्त, स्ट्रक्चर्ड सारांश लौटाता है।

def generate_summary(client, audio_file_path):
    try:
        audio_chunk = file_to_chunk(audio_file_path)
        text_chunk = TextChunk(text="Please provide a comprehensive summary of this audio content, highlighting the key points and main themes discussed.")
        user_msg = UserMessage(content=[audio_chunk, text_chunk]).to_openai()    
        response = client.chat.completions.create(
            model=Config.MODEL_NAME,
            messages=[user_msg],
            temperature=Config.DEFAULT_TEMPERATURE,
            top_p=Config.DEFAULT_TOP_P,
        )
        return response.choices[0].message.content
    except Exception as e:
        st.error(f"Error generating summary: {str(e)}")
        return Noneसंचालित द्वारा

ऊपर दिया गया कोड अपलोडेड ऑडियो से सारांश जनरेट करने के लिए कई मुख्य मेथड्स और फ़ंक्शंस का उपयोग करता है:

• audio_chunk: पहले, अपलोडेड ऑडियो फ़ाइल को Voxtral की ऑडियो प्रोसेसिंग के लिए AudioChunk में कन्वर्ट करते हैं।
• text_chunk: फिर, मॉडल को स्पष्ट और व्यापक तरीके से कंटेंट का सारांश देने का निर्देश देने हेतु एक टेक्स्ट प्रॉम्प्ट उपयोग करते हैं।
• UserMessage: यह audio_chunk और text_chunk को एक सिंगल मल्टीमॉडल मैसेज में OpenAI‑कम्पैटिबल फॉर्मैट में जोड़ता है। 
• Response.choices[0].message.content: यह ऑब्जेक्ट मॉडल के रिस्पॉन्स से वास्तविक सारांश टेक्स्ट निकालता है।

चरण 4.5: ऑडियो पर मल्टीलिंगुअल Q&A

अब हमारे पास सारांश है। आइए यूज़र्स को अपलोडेड ऑडियो कंटेंट के बारे में नैचुरल लैंग्वेज में प्रश्न पूछने दें। यह Voxtral की मल्टीमॉडल क्षमताओं का उपयोग करता है—ऑडियो को टेक्स्ट प्रॉम्प्ट्स के साथ मिलाकर संदर्भ‑समझ वाले उत्तर जनरेट करने के लिए।

निम्न फ़ंक्शन चयनित भाषा के आधार पर प्रॉम्प्ट को डायनमिक रूप से मॉडिफ़ाई करके मल्टीलिंगुअल रिस्पॉन्स भी सपोर्ट करता है।

def ask_question(client, audio_file_path, question, language="English"):
    try:
        audio_chunk = file_to_chunk(audio_file_path)
        if language != "English":
            question = f"Please answer the following question in {language}: {question}"
        text_chunk = TextChunk(text=question)
        user_msg = UserMessage(content=[audio_chunk, text_chunk]).to_openai()        
        response = client.chat.completions.create(
            model=Config.MODEL_NAME,
            messages=[user_msg],
            temperature=Config.DEFAULT_TEMPERATURE,
            top_p=Config.DEFAULT_TOP_P,
        )        
        return response.choices[0].message.content
    except Exception as e:
        st.error(f"Error asking question: {str(e)}")
        return Noneसंचालित द्वारा

ऊपर दिए गए कोड स्निपेट में क्या हो रहा है, इसका खाका:

• ask_question() फ़ंक्शन यूज़र्स को अपलोडेड ऑडियो के बारे में कोई भी प्रश्न पूछने देता है।
• यह file_to_chunk() रीयूज़ेबल फ़ंक्शन का उपयोग करके अपलोडेड फ़ाइल को AudioChunk में कन्वर्ट करके शुरू करता है, जो Voxtral की मल्टीमॉडल API द्वारा अपेक्षित फॉर्मैट है।
• फिर यह चयनित भाषा की जाँच करता है। यदि वह अंग्रेज़ी नहीं है, तो यूज़र के प्रश्न के पहले एक निर्देश जोड़ता है कि उत्तर इच्छित भाषा में दें (जैसे, हिंदी या स्पैनिश)।
• यूज़र का प्रश्न TextChunk में रैप किया जाता है, और ऑडियो व टेक्स्ट दोनों को एक मल्टीमॉडल UserMessage में बंडल किया जाता है।
• हम यह मैसेज मॉडल को भेजते हैं, और जेनरेशन क्वालिटी कंट्रोल के लिए कॉन्फ़िग से टेम्परेचर और टॉप‑p वैल्यूज़ पास करते हैं।
• मॉडल फिर एक सिंगल‑टर्न रिस्पॉन्स लौटाता है।

चरण 4.6: साइडबार सेट करना

साइडबार एक कंट्रोल पैनल के रूप में काम करता है, जो यूज़र्स को सेशन सेटिंग्स मैनेज करने, आउटपुट भाषा चुनने, Voxtral API से कनेक्शन टेस्ट करने और सहज स्लाइडर्स के ज़रिए मॉडल के रिस्पॉन्स व्यवहार को कस्टमाइज़ करने देता है।

def render_sidebar():
    with st.sidebar:
        st.markdown('<h3 class="section-header">Configuration</h3>', unsafe_allow_html=True)        
        # Connection status
        st.markdown('<h4>Connection Status</h4>', unsafe_allow_html=True)
        if st.button("Test Connection"):
            client = initialize_client()
            if client:
                st.success("Connected to Voxtral API")
            else:
                st.error("Connection failed")        
        # Language selection
        selected_language = st.selectbox("Select language for Q&A:", Config.SUPPORTED_LANGUAGES)        
        # Model configuration
        st.markdown('<h4>Model Settings</h4>', unsafe_allow_html=True)
        temperature = st.slider("Temperature", 0.0, 1.0, Config.DEFAULT_TEMPERATURE, 0.1)
        top_p = st.slider("Top P", 0.0, 1.0, Config.DEFAULT_TOP_P, 0.05)
        if st.button("Clear Session"):
            for key in ['transcription', 'summary', 'chat_history', 'audio_file_path']:
                st.session_state[key] = "" if key in ['transcription', 'summary'] else [] if key == 'chat_history' else None
            st.rerun()        
        return selected_language, temperature, top_pसंचालित द्वारा

ऊपर दिए गए कोड का ब्रेकडाउन:

• साइडबार: st.sidebar एक कोलेप्सिबल साइडबार खोलता है जहाँ हम ऐप के लिए कॉन्फ़िगरेशन टूल रखते हैं।
• कनेक्शन टेस्ट: "Test Connection" बटन initialize_client() फ़ंक्शन को ट्रिगर करता है, जो Voxtral API से कनेक्ट होने की कोशिश करता है और Streamlit अलर्ट्स से सफलता/विफलता रिपोर्ट करता है।
• भाषा चयन: एक ड्रॉपडाउन यूज़र को 12 सपोर्टेड भाषाओं में से चुनने देता है। यह चयन आगे मॉडल को उसी भाषा में जवाब देने को सूचित करता है।
• मॉडल पैरामीटर्स: स्लाइडर यूज़र को निम्न पैरामीटर्स कंट्रोल करने देता है:
• temperature: क्रिएटिविटी कंट्रोल करता है। कम वैल्यूज़ रिस्पॉन्स को अधिक निर्धारक बनाती हैं, जबकि अधिक वैल्यूज़ उन्हें विविध बनाती हैं।
• top_p: न्यूक्लियस सैंपलिंग कंट्रोल करता है, जो जेनरेशन को सबसे संभावित टोकन्स तक सीमित करने में मदद करता है।
• सेशन रीसेट: "Clear Session" बटन सभी सेशन स्टेट वेरिएबल्स रीसेट करता है और ऐप को फ्रेश स्टार्ट के लिए दोबारा रन करता है।

चरण 4.7: ऑडियो अपलोड और प्रोसेसिंग सेक्शन

यह सेक्शन यूज़र्स को (.mp3, .wav, आदि) ऑडियो फ़ाइलें अपलोड करने देता है, जिन्हें अस्थायी रूप से सेव किया जाता है। अपलोड होने के बाद, यूज़र या तो ऑडियो को ट्रांसक्राइब कर सकते हैं या एक हाई‑लेवल सारांश जनरेट कर सकते हैं। 

def render_audio_processing():
    st.markdown('<h3 class="section-header">Audio Upload & Processing</h3>', unsafe_allow_html=True)    
    uploaded_file = st.file_uploader(
        "Choose an audio file",
        type=Config.SUPPORTED_AUDIO_FORMATS,
        help="Upload an audio file to transcribe and analyze"
    )
    if uploaded_file is not None:
        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{uploaded_file.name.split('.')[-1]}") as tmp_file:
            tmp_file.write(uploaded_file.getvalue())
            st.session_state.audio_file_path = tmp_file.name
        st.success(f"File uploaded: {uploaded_file.name}")
        # Initialize client
        client = initialize_client()
        col1, col2 = st.columns(2) 
        with col1:
            if st.button("Generate Summary", type="primary"):
                with st.spinner("Generating summary..."):
                    summary = generate_summary(client, st.session_state.audio_file_path)
                    if summary:
                        st.session_state.summary = summary
        with col2:
            if st.button("Transcribe Audio", type="secondary"):
                with st.spinner("Transcribing audio..."):
                    transcription = transcribe_audio(client, st.session_state.audio_file_path)
                    if transcription:
                        st.session_state.transcription = transcription
        if st.session_state.summary:
            st.markdown('<h4>Summary</h4>', unsafe_allow_html=True)
            st.markdown(f'<div class="success-box">{st.session_state.summary}</div>', unsafe_allow_html=True)
        if st.session_state.transcription:
            st.markdown('<h4>Audio Transcription</h4>', unsafe_allow_html=True)
            st.text_area("Transcription", st.session_state.transcription, height=200, label_visibility="collapsed")संचालित द्वारा

हमें एक मॉड्यूलर स्ट्रक्चर चाहिए ताकि ऑडियो अपलोड, प्रोसेसिंग और रिज़ल्ट्स का परसिस्टेंट स्टोरेज आसान हो। मैंने इसे ऐसे किया:

• फ़ाइल अपलोडर: पहले, हमें एक ड्रैग‑एंड‑ड्रॉप फ़ाइल अपलोडर चाहिए जो Config.SUPPORTED_AUDIO_FORMATS में परिभाषित कई ऑडियो फ़ॉर्मैट स्वीकार करता हो। फ़ाइल अपलोड होने पर, इसे एक अस्थायी फ़ाइल में लिखा जाता है और st.session_state.audio_file_path में सेव किया जाता है।
• क्लाइंट इनिशियलाइज़ेशन: सारांश और ट्रांसक्रिप्शन के लिए कॉल करने हेतु Voxtral‑कम्पैटिबल क्लाइंट इनिशियलाइज़ किया जाता है।
• सारांश और ट्रांसक्रिप्शन बटन: फिर, हम दो बटन परिभाषित करते हैं:
• Generate summary: क्लिक करने पर यह बटन अपलोडेड ऑडियो को सारांश प्रॉम्प्ट के साथ मॉडल को भेजता है। एक प्रोग्रेस स्पिनर दिखता है और सफल होने पर आउटपुट st.session_state.summary में सेव होता है।
• Transcribe audio: यह बटन ऑडियो फ़ाइल को ट्रांसक्रिप्शन एंडपॉइंट पर भेजता है। स्पिनर के साथ रीयल‑टाइम प्रोग्रेस दिखाई जाती है और रिज़ल्ट st.session_state.transcription में स्टोर होता है।
• अंत में, दोनों रिज़ल्ट्स टेक्स्ट एरिया में दिखाए जाते हैं।

चरण 4.8: इंटरैक्टिव मल्टीलिंगुअल Q&A

यह चरण यूज़र्स को अपलोडेड ऑडियो के बारे में कई भाषाओं (जैसे, अंग्रेज़ी, हिंदी, स्पैनिश) में प्रश्न पूछने देता है। चयनित भाषा का उपयोग मॉडल के रिस्पॉन्स को फॉर्मैट करने में होता है, और हर प्रश्न‑उत्तर जोड़ी सेशन‑मैनेज्ड बातचीत इतिहास में स्टोर होकर चैट बबल्स में दिखाई जाती है।

def render_qa_section(selected_language):
    st.markdown('<h3 class="section-header">Multilingual Q&A</h3>', unsafe_allow_html=True) 
    if st.session_state.audio_file_path:
        st.markdown(f'<div class="info-box">Selected language: <strong>{selected_language}</strong></div>', unsafe_allow_html=True)
        question = st.text_input(
            f"Ask a question about the audio (in {selected_language}):",
            placeholder="e.g., What is the main topic discussed?"
        )    
        if st.button("Ask Question", type="primary") and question:
            client = initialize_client()
            with st.spinner("Processing your question..."):
                answer = ask_question(client, st.session_state.audio_file_path, question, selected_language)
                if answer:
                    # Chat history
                    st.session_state.chat_history.append({
                        "question": question,
                        "answer": answer,
                        "language": selected_language,
                        "timestamp": time.strftime("%H:%M:%S")
                    })
                    st.success("Question answered!")
                else:
                    st.error("Failed to get answer. Please try again.")
                if st.session_state.chat_history:
            st.markdown('<h4>Conversation History</h4>', unsafe_allow_html=True)
            for chat in reversed(st.session_state.chat_history):
                st.markdown(f'<div class="chat-message user-message"><strong>Question:</strong> {chat["question"]}</div>', unsafe_allow_html=True)
                st.markdown(f'<div class="chat-message assistant-message"><strong>Answer:</strong> {chat["answer"]}</div>', unsafe_allow_html=True)
                st.markdown("---")
    else:
        st.markdown('<div class="info-box">Please upload an audio file to start asking questions.</div>', unsafe_allow_html=True)संचालित द्वारा

ऊपर दिए गए कोड स्निपेट में क्या हो रहा है, इसका ब्रेकडाउन:

• Ask Question बटन: टेक्स्ट इनपुट फ़ील्ड यूज़र को चयनित भाषा में प्रश्न टाइप करने देता है और Ask Question बटन पर क्लिक करने देता है। क्लिक करने पर यह:
• Voxtral‑कम्पैटिबल क्लाइंट इनिशियलाइज़ करता है।
• अपलोडेड ऑडियो के साथ प्रश्न मॉडल को भेजता है।
• मॉडल के रिस्पॉन्स का इंतज़ार करते समय स्पिनर दिखाता है।
• रिस्पॉन्स हैंडलिंग: यदि रिस्पॉन्स मिलता है, तो उसे:
• st.session_state.chat_history में टाइमस्टैम्प के साथ स्टोर किया जाता है।
• पहले से परिभाषित कस्टम CSS का उपयोग करके रोल‑विशिष्ट फॉर्मैटिंग (यूज़र बनाम असिस्टेंट बबल) के साथ रेंडर किया जाता है।
• यदि मॉडल विफल हो, तो स्पष्ट एरर मैसेज दिखाया जाता है।
• कन्वर्सेशन हिस्ट्री: यदि पहले के Q&A पेयर्स मौजूद हैं, तो उन्हें रिवर्स क्रोनोलॉजिकल ऑर्डर में सेपरेटर के साथ दिखाया जाता है।

चरण 4.9: ऐप लॉन्च करना

यह अंतिम चरण सभी पहले परिभाषित कम्पोनेंट्स को एक साथ लाता है—सेशन स्टेट इनिशियलाइज़ करना, साइडबार रेंडर करना, ऑडियो अपलोड हैंडल करना, ट्रांसक्रिप्शन, सारांश और Q&A—दो‑कॉलम लेआउट का उपयोग करते हुए।

एक बार सर्वर चल रहा हो और सभी डिपेंडेंसियाँ इंस्टॉल हो जाएँ, यह चरण सुनिश्चित करता है कि ऐप Streamlit के माध्यम से ब्राउज़र में सर्व हो और इंटरैक्शन के लिए तैयार हो।

def main():
    st.markdown('<h1 class="main-header">🎵 Voxtral Audio Assistant</h1>', unsafe_allow_html=True)
    # Initialize session state
    init_session_state()
    # Render sidebar and get configuration
    selected_language, temperature, top_p = render_sidebar()
    col1, col2 = st.columns([1, 1]) 
    with col1:
        render_audio_processing()
    with col2:
        render_qa_section(selected_language)
    st.markdown("---")
    st.markdown("""
    <div style="text-align: center;">
        <p>Powered by <strong>Voxtral Mini 3B</strong> | Built with Streamlit</p>
        <p>Supports multiple languages for audio analysis and Q&A</p>
    </div>
    """, unsafe_allow_html=True)
if __name__ == "__main__":
    main() संचालित द्वारा

main() फ़ंक्शन ऐप का एंट्री पॉइंट है। यह लेआउट कंट्रोल करता है, रेंडरिंग ऑर्केस्ट्रेट करता है और सुनिश्चित करता है कि सभी सेशन वेरिएबल्स और UI कम्पोनेंट्स ठीक से इनिशियलाइज़ हों। ऊपर परिभाषित फ़ंक्शंस का सार यह है:

• init_session_state(): यह फ़ंक्शन transcription, summary और chat_history जैसी डिफ़ॉल्ट वैल्यूज़ तैयार करता है ताकि ऐप स्टेट इंटरैक्शंस के दौरान बना रहे।
• render_sidebar(): यह भाषा चयनकर्ता, कनेक्शन टेस्ट और मॉडल पैरामीटर्स सहित कॉन्फ़िगरेशन विड्जेट्स लोड करता है।
• render_audio_processing(): यह फ़ंक्शन यूज़र्स को ट्रांसक्रिप्शन और सारांश जनरेशन के लिए ऑडियो फ़ाइलें अपलोड और प्रोसेस करने देता है।
• render_qa_section(): अंततः, यह फ़ंक्शन अपलोडेड ऑडियो पर मल्टीलिंगुअल प्रश्न‑उत्तर को सक्षम बनाता है।

सब कुछ तैयार होने के बाद, ऐप को निम्न चलाकर रन करें:

pip install -r requirements.txtसंचालित द्वारा

config.py के अंदर VOXTRAL_API_BASE में निर्दिष्ट URL के माध्यम से यह एक्सेसिबल होना चाहिए। सभी डिपेंडेंसियाँ इंस्टॉल हो जाने पर, टर्मिनल में निम्न कमांड चलाकर Streamlit एप्लिकेशन रन करें:

streamlit run app.pyसंचालित द्वारा

आपका ब्राउज़र इंटरफ़ेस को अपने‑आप खोल देगा। अब ऐप Voxtral Mini 3B द्वारा संचालित ऑडियो अपलोड, रीयल‑टाइम ट्रांसक्रिप्शन, सारांश और मल्टीलिंगुअल Q&A के साथ पूरी तरह फ़ंक्शनल है।