वॉयस एजेंट नवीनता के एक साधन से बदलकर आधुनिक डिजिटल इंटरैक्शन के एक मौलिक घटक बन गए हैं। स्मार्ट होम हब से लेकर जटिल कस्टमर सर्विस प्लेटफॉर्म तक, परिष्कृत वॉयस एआई का निर्माण और उपयोग करना डेवलपर्स के लिए एक महत्वपूर्ण कौशल है। इस बाजार के तेजी से विस्तार की संभावना है, जो 2024 में $14.8 बिलियन से बढ़कर 2033 तक $61 बिलियन से अधिक होने का अनुमान है (AssemblyAI, 2026)। 8.4 बिलियन से अधिक सक्रिय वॉयस असिस्टेंट पहले से ही उपयोग में हैं - जो वैश्विक जनसंख्या से भी अधिक हैं (SeoProfy, 2025) - अवसर निर्विवाद रूप से काफी बड़ा है।

यह गाइड उन पायथन डेवलपर्स के लिए है जो शुरुआत से ही वॉयस एजेंट बनाना चाहते हैं। चाहे आप कोई पर्सनल असिस्टेंट बनाने वाले शौकिया व्यक्ति हों या किसी एप्लीकेशन में आवाज को एकीकृत करने वाले पेशेवर, यह ट्यूटोरियल एक स्पष्ट और व्यावहारिक रास्ता प्रदान करता है। हम पूरे वर्कफ़्लो को कवर करेंगे: अपना एनवायरनमेंट सेटअप करना, आवाज को कैप्चर करना और समझना, कमांड को प्रोसेस करना और बोलकर जवाब देना। अंत तक, आपके पास एक कार्यात्मक एजेंट होगा जिसे आप कस्टमाइज़ कर सकते हैं। हम व्यापक रूप से उपलब्ध पायथन लाइब्रेरीज़ का उपयोग करेंगे, जिससे आप रीयल-टाइम पर्सनलाइज़ेशन और इमोशन डिटेक्शन (CallBotics, 2026) जैसी भविष्य की सुविधाओं को शामिल करने वाले अधिक उन्नत सिस्टम्स पर काम करने से पहले बुनियादी कौशल हासिल कर सकें।

पूर्वापेक्षाएँ (Prerequisites): आपको किसकी आवश्यकता होगी

बिल्डिंग शुरू करने से पहले, आइए सुनिश्चित करें कि आपके पास सही उपकरण हैं। यह ट्यूटोरियल मानकर चलता है कि आपको पायथन प्रोग्रामिंग की बुनियादी समझ है, लेकिन इसके लिए आपको मशीन लर्निंग विशेषज्ञ होने की आवश्यकता नहीं है। ये उदाहरण मानक लाइब्रेरीज़ का उपयोग करते हैं और स्पष्टता के लिए लिखे गए हैं।

यहाँ आवश्यक चीजों की एक चेकलिस्ट दी गई है:

• पायथन 3.8 या नया संस्करण: सुनिश्चित करें कि पायथन का नवीनतम संस्करण इंस्टॉल है। आप इसे पायथन की आधिकारिक वेबसाइट से प्राप्त कर सकते हैं। हम `pip` का उपयोग करेंगे, जो कि आधुनिक पायथन इंस्टॉलेशन के साथ आने वाला पैकेज इंस्टॉलर है।

• एक कोड एडिटर या IDE: हालांकि कोई भी टेक्स्ट एडिटर काम कर सकता है, विज़ुअल स्टूडियो कोड (Visual Studio Code) या PyCharm जैसी इंटीग्रेटेड डेवलपमेंट एनवायरनमेंट (IDE) सिंटैक्स हाइलाइटिंग और डिबगिंग के साथ अधिक सहज अनुभव प्रदान करेगी।

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

• बुनियादी कमांड लाइन कौशल: आपको पैकेज इंस्टॉल करने और स्क्रिप्ट चलाने के लिए टर्मिनल खोलने, डायरेक्टरी नेविगेट करने और कमांड चलाने में सहज होना चाहिए।

• इंटरनेट कनेक्शन: जिन स्पीच रिकग्निशन सेवाओं का हम उपयोग करेंगे, उनमें से कई को काम करने के लिए इंटरनेट कनेक्शन की आवश्यकता होती है।

आपको स्पीच रिकग्निशन या टेक्स्ट-टू-स्पीच APIs का कोई पूर्व अनुभव होने की आवश्यकता नहीं है। हम सभी आवश्यक अवधारणाओं और लाइब्रेरी के उपयोग को बिल्कुल बुनियादी स्तर से कवर करेंगे।

स्टेप 1: अपना पायथन एनवायरनमेंट सेटअप करना

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

सबसे पहले, अपना टर्मिनल या कमांड प्रॉम्प्ट खोलें, अपने प्रोजेक्ट के लिए एक नई डायरेक्टरी बनाएं और उसमें जाएं।

BASH

mkdir python_voice_agent
cd python_voice_agent

mkdir python_voice_agent
cd python_voice_agent

mkdir python_voice_agent
cd python_voice_agent

अब, इस फ़ोल्डर के अंदर एक वर्चुअल एनवायरनमेंट बनाएं। यह कमांड ऑपरेटिंग सिस्टम के आधार पर थोड़ा भिन्न हो सकता है।

macOS और Linux पर:

BASH

python3 -m venv venv

python3 -m venv venv

python3 -m venv venv

Windows पर:

BASH

python -m venv venv

python -m venv venv

python -m venv venv

यह कमांड `venv` नाम का एक नया फ़ोल्डर बनाता है। इसका उपयोग शुरू करने के लिए, आपको इसे सक्रिय (activate) करना होगा।

macOS और Linux पर:

BASH

source venv/bin/activate

source venv/bin/activate

source venv/bin/activate

Windows पर:

BASH

.\venv

.\venv

.\venv

एक बार सक्रिय होने के बाद, आपका टर्मिनल प्रॉम्प्ट शुरुआत में `(venv)` दिखाने के लिए बदलना चाहिए, जो यह दर्शाता है कि आपके द्वारा इंस्टॉल किए गए कोई भी पायथन पैकेज इसी एनवायरनमेंट तक सीमित रहेंगे।

कोर लाइब्रेरीज़ को इंस्टॉल करना

एनवायरनमेंट के सक्रिय होने पर, हम उन पायथन लाइब्रेरीज़ को इंस्टॉल कर सकते हैं जो मुख्य काम करेंगी। हम ऑडियो को टेक्स्ट में बदलने के लिए `SpeechRecognition` और ऑफलाइन टेक्स्ट-टू-स्पीच कन्वर्शन के लिए `pyttsx3` पर भरोसा करेंगे (Analytics Vidhya, 2025)। माइक्रोफ़ोन इनपुट को संभालने के लिए हमें `PyAudio` की भी आवश्यकता होगी।

अपने सक्रिय टर्मिनल में इन कमांड्स को चलाएं:

BASH

pip install SpeechRecognition
pip install pyttsx3
pip install PyAudio

pip install SpeechRecognition
pip install pyttsx3
pip install PyAudio

pip install SpeechRecognition
pip install pyttsx3
pip install PyAudio

स्टेप 2: स्पीच रिकग्निशन के लिए लिसनर तैयार करना

हमारे एजेंट का पहला सक्रिय घटक उसके 'कान' हैं। यह लिसनर मॉड्यूल माइक्रोफ़ोन से ऑडियो कैप्चर करने और उसे टेक्स्ट में ट्रांसक्राइब करने के लिए ज़िम्मेदार है। हम `SpeechRecognition` लाइब्रेरी का उपयोग करेंगे, जो चालाकी से कई अलग-अलग स्पीच रिकग्निशन इंजन को रैप करती है। इस काम के लिए, हम गूगल के वेब स्पीच एपीआई (Web Speech API) से शुरुआत करेंगे - यह मुफ़्त, आसान और टेस्टिंग के लिए बढ़िया है, लेकिन इसके लिए इंटरनेट कनेक्शन की आवश्यकता होती है।

`listener.py` नाम से एक नई फ़ाइल बनाएं और निम्नलिखित कोड जोड़ें:

PYTHON

import speech_recognition as sr
<p>def listen_for_command():<br>"""Listens for a command from the user and returns it as text."""<br>r = sr.Recognizer()</p>
<pre><code>with sr.Microphone() as source:
    print("Listening for a command...")
    r.pause_threshold = 1
    r.adjust_for_ambient_noise(source, duration=1)
    audio = r.listen(source)

try:
    print("Recognizing...")
    command = r.recognize_google(audio, language='en-US')
    print(f"User said: {command}\n")
    return command.lower()
except sr.UnknownValueError:
    print("Sorry, I did not understand that.")
    return ""
except sr.RequestError as e:
    print(f"Could not request results from Google Speech Recognition service; {e}")
    return ""
</code></pre>

import speech_recognition as sr
<p>def listen_for_command():<br>"""Listens for a command from the user and returns it as text."""<br>r = sr.Recognizer()</p>
<pre><code>with sr.Microphone() as source:
    print("Listening for a command...")
    r.pause_threshold = 1
    r.adjust_for_ambient_noise(source, duration=1)
    audio = r.listen(source)

try:
    print("Recognizing...")
    command = r.recognize_google(audio, language='en-US')
    print(f"User said: {command}\n")
    return command.lower()
except sr.UnknownValueError:
    print("Sorry, I did not understand that.")
    return ""
except sr.RequestError as e:
    print(f"Could not request results from Google Speech Recognition service; {e}")
    return ""
</code></pre>

import speech_recognition as sr
<p>def listen_for_command():<br>"""Listens for a command from the user and returns it as text."""<br>r = sr.Recognizer()</p>
<pre><code>with sr.Microphone() as source:
    print("Listening for a command...")
    r.pause_threshold = 1
    r.adjust_for_ambient_noise(source, duration=1)
    audio = r.listen(source)

try:
    print("Recognizing...")
    command = r.recognize_google(audio, language='en-US')
    print(f"User said: {command}\n")
    return command.lower()
except sr.UnknownValueError:
    print("Sorry, I did not understand that.")
    return ""
except sr.RequestError as e:
    print(f"Could not request results from Google Speech Recognition service; {e}")
    return ""
</code></pre>

लिसनर कोड का विश्लेषण

आइए देखें कि यह स्क्रिप्ट क्या करती है। लाइब्रेरी को sr के रूप में इम्पोर्ट करने के बाद, listen_for_command फ़ंक्शन एक Recognizer ऑब्जेक्ट को इनिशियलाइज़ करता है, जो लाइब्रेरी की कार्यक्षमता का मूल हिस्सा है।

मुख्य ऑपरेशन्स हैं:

• with sr.Microphone() as source: डिफ़ॉल्ट माइक्रोफ़ोन खोलता है और सुनिश्चित करता है कि उपयोग के बाद इसे ठीक से जारी (release) कर दिया जाए।

• सटीकता के लिए r.adjust_for_ambient_noise(...) एक महत्वपूर्ण कदम है। यह रिकग्नाइज़र को परिवेश के शोर के स्तर (ambient noise level) के अनुसार कैलिब्रेट करने के लिए एक सेकंड के लिए सुनता है, जिससे इसे बैकग्राउंड के शोर से आवाज को अलग करने में मदद मिलती है।

• audio = r.listen(source) माइक्रोफ़ोन से ऑडियो तब तक कैप्चर करता है जब तक कि उसे बोलने में कोई ठहराव (pause) महसूस न हो।

• command = r.recognize_google(...) कैप्चर किए गए ऑडियो को ट्रांसक्रिप्शन के लिए गूगल के API को भेजता है। परिणाम एक स्ट्रिंग होता है।

• try...except ब्लॉक त्रुटियों (errors) को शालीनता से संभालता है, जैसे कि जब API ऑडियो को समझने में असमर्थ हो (UnknownValueError) या जब कोई नेटवर्क समस्या हो (RequestError), जो प्रोग्राम को क्रैश होने से बचाता है।

आप अपने टर्मिनल में python listener.py चलाकर सीधे इस फ़ाइल का परीक्षण कर सकते हैं। संकेत मिलने पर, अपने माइक्रोफ़ोन में स्पष्ट रूप से बोलें, और आपका ट्रांसक्राइब किया गया भाषण दिखाई देना चाहिए। लाइब्रेरी की क्षमताओं के बारे में अधिक जानकारी के लिए, आधिकारिक SpeechRecognition Library Documentation एक उत्कृष्ट संसाधन है, और यह किसी भी Python speech recognition guide के लिए एक आवश्यक उपकरण है।

स्टेप 3: टेक्स्ट-टू-स्पीच (TTS) के लिए स्पीकर बनाना

अब जबकि हमारा एजेंट सुन सकता है, इसे आवाज देने का समय आ गया है। स्पीकर मॉड्यूल टेक्स्ट की एक स्ट्रिंग लेगा और उसे pyttsx3 लाइब्रेरी का उपयोग करके बोले जाने वाले ऑडियो में बदल देगा। pyttsx3 का मुख्य लाभ यह है कि यह आपके ऑपरेटिंग सिस्टम (जैसे विंडोज पर SAPI5 या macOS पर NSSpeechSynthesizer) में निर्मित TTS इंजन का उपयोग करके पूरी तरह से ऑफ़लाइन काम करता है। यह इसे तेज़ और विश्वसनीय बनाता है, जिसमें किसी API कुंजी या इंटरनेट निर्भरता की आवश्यकता नहीं होती।

speaker.py नाम से एक नई फ़ाइल बनाएं और यह कोड जोड़ें:

PYTHON

import pyttsx3<p></p>
<p>engine = pyttsx3.init()</p>
<p>def configure_voice():<br>"""Configures the properties of the TTS voice."""<br>voices = engine.getProperty("voices")<br># You can change the index to select a different voice<br>engine.setProperty("voice", voices[0].id)</p>
<pre><code>rate = engine.getProperty("rate")
engine.setProperty("rate", 150)  # Speed of speech
</code></pre>
<p>def speak(text):<br>"""Converts text to speech."""<br>engine.say(text)<br>engine.runAndWait()</p>

import pyttsx3<p></p>
<p>engine = pyttsx3.init()</p>
<p>def configure_voice():<br>"""Configures the properties of the TTS voice."""<br>voices = engine.getProperty("voices")<br># You can change the index to select a different voice<br>engine.setProperty("voice", voices[0].id)</p>
<pre><code>rate = engine.getProperty("rate")
engine.setProperty("rate", 150)  # Speed of speech
</code></pre>
<p>def speak(text):<br>"""Converts text to speech."""<br>engine.say(text)<br>engine.runAndWait()</p>

import pyttsx3<p></p>
<p>engine = pyttsx3.init()</p>
<p>def configure_voice():<br>"""Configures the properties of the TTS voice."""<br>voices = engine.getProperty("voices")<br># You can change the index to select a different voice<br>engine.setProperty("voice", voices[0].id)</p>
<pre><code>rate = engine.getProperty("rate")
engine.setProperty("rate", 150)  # Speed of speech
</code></pre>
<p>def speak(text):<br>"""Converts text to speech."""<br>engine.say(text)<br>engine.runAndWait()</p>

स्पीकर कोड को समझना

यह स्क्रिप्ट काफी सीधी है। हम pyttsx3 इंजन को इनिशियलाइज़ करते हैं, और configure_voice फ़ंक्शन कस्टमाइज़ेशन की अनुमति देता है। आप अपने सिस्टम पर उपलब्ध आवाज़ों की सूची प्राप्त कर सकते हैं और बोलने की गति (speaking rate) जैसे गुणों को समायोजित कर सकते हैं। मुख्य कार्यक्षमता speak फ़ंक्शन में है:

• engine.say(text) उस टेक्स्ट को कतार (queue) में रखता है जिसे आप इंजन से बुलवाना चाहते हैं।

• engine.runAndWait() कतार को प्रोसेस करता है। यह एक ब्लॉकिंग कॉल है, जिसका अर्थ है कि बोलना समाप्त होने तक आपका प्रोग्राम रुक जाएगा, जो एक संवादात्मक एजेंट के लिए एकदम सही है।

परीक्षण वाक्यांशों (test phrases) को सुनने के लिए python speaker.py चलाएं। अपनी पसंद की सेटिंग खोजने के लिए वॉयस इंडेक्स बदलने या गति को समायोजित करने का प्रयोग करें। हालांकि ऑफ़लाइन प्रोजेक्ट्स के लिए pyttsx3 बहुत अच्छा है, लेकिन प्रोडक्शन सिस्टम अक्सर उच्च-गुणवत्ता वाली आवाज़ों के लिए क्लाउड-आधारित APIs का उपयोग करते हैं। इस प्रक्रिया में व्यापक प्रकार की आवाज़ें और भावनात्मक टोन की पेशकश करने वाली सेवाओं के साथ building realistic text-to-speech in Python शामिल है। आप pyttsx3 Library Documentation में अधिक विवरण पा सकते हैं।

स्टेप 4: मुख्य तर्क (Core Logic) और कमांड प्रोसेसिंग विकसित करना

यह हमारे वॉयस एजेंट का 'दिमाग' है। यह लिसनर से ट्रांसक्राइब किया गया टेक्स्ट प्राप्त करता है, उपयोगकर्ता के इरादे (intent) को निर्धारित करता है, और कार्रवाई का निर्णय लेता है। इस गाइड के लिए, हम बुनियादी स्ट्रिंग मैचिंग का उपयोग करके एक सरल कमांड-एंड-कंट्रोल संरचना लागू करेंगे। यद्यपि आधुनिक वॉयस एजेंट जटिल, बहु-चरणीय लेनदेन (transactions) को संभाल सकते हैं (RingCentral, 2026), यह कीवर्ड-आधारित दृष्टिकोण शुरू करने के लिए एक शानदार स्थान है।

कमांड-हैंडलिंग लॉजिक के लिए processor.py नाम से एक फ़ाइल बनाएं।

PYTHON

import datetime<br>import webbrowser<p></p>
<p>def process_command(command):<br>"""Processes the command and returns a response."""<br>response = ""</p>
<pre><code>if "hello" in command:
    response = "Hello! How can I help you today?"
elif "time" in command:
    now = datetime.datetime.now().strftime("%I:%M %p")
    response = f"The current time is {now}."
elif "date" in command:
    today = datetime.date.today().strftime("%B %d, %Y")
    response = f"Today's date is {today}."
elif "open google" in command:
    response = "Opening Google."
    webbrowser.open("https://www.google.com")
elif "search for" in command:
    # Example: "search for Python tutorials"
    search_term = command.split("search for")[-1].strip()
    url = f"https://www.google.com/search?q={search_term}"
    webbrowser.open(url)
    response = f"Here are the search results for {search_term}."
elif "goodbye" in command or "exit" in command:
    response = "Goodbye!"
else:
    response = "I'm sorry, I don't know how to do that yet."

return response
</code></pre>

import datetime<br>import webbrowser<p></p>
<p>def process_command(command):<br>"""Processes the command and returns a response."""<br>response = ""</p>
<pre><code>if "hello" in command:
    response = "Hello! How can I help you today?"
elif "time" in command:
    now = datetime.datetime.now().strftime("%I:%M %p")
    response = f"The current time is {now}."
elif "date" in command:
    today = datetime.date.today().strftime("%B %d, %Y")
    response = f"Today's date is {today}."
elif "open google" in command:
    response = "Opening Google."
    webbrowser.open("https://www.google.com")
elif "search for" in command:
    # Example: "search for Python tutorials"
    search_term = command.split("search for")[-1].strip()
    url = f"https://www.google.com/search?q={search_term}"
    webbrowser.open(url)
    response = f"Here are the search results for {search_term}."
elif "goodbye" in command or "exit" in command:
    response = "Goodbye!"
else:
    response = "I'm sorry, I don't know how to do that yet."

return response
</code></pre>

import datetime<br>import webbrowser<p></p>
<p>def process_command(command):<br>"""Processes the command and returns a response."""<br>response = ""</p>
<pre><code>if "hello" in command:
    response = "Hello! How can I help you today?"
elif "time" in command:
    now = datetime.datetime.now().strftime("%I:%M %p")
    response = f"The current time is {now}."
elif "date" in command:
    today = datetime.date.today().strftime("%B %d, %Y")
    response = f"Today's date is {today}."
elif "open google" in command:
    response = "Opening Google."
    webbrowser.open("https://www.google.com")
elif "search for" in command:
    # Example: "search for Python tutorials"
    search_term = command.split("search for")[-1].strip()
    url = f"https://www.google.com/search?q={search_term}"
    webbrowser.open(url)
    response = f"Here are the search results for {search_term}."
elif "goodbye" in command or "exit" in command:
    response = "Goodbye!"
else:
    response = "I'm sorry, I don't know how to do that yet."

return response
</code></pre>

यह फ़ंक्शन कीवर्ड की जांच करने के लिए if/elif/else स्टेटमेंट्स की एक श्रृंखला का उपयोग करता है। यदि कोई कीवर्ड मिल जाता है, तो यह एक कार्रवाई करता है, जैसे कि datetime मॉड्यूल के साथ समय प्राप्त करना या webbrowser मॉड्यूल के साथ एक वेब पेज खोलना। यदि कोई कीवर्ड मेल नहीं खाता है, तो यह एक डिफ़ॉल्ट फ़ॉलबैक प्रतिक्रिया देता है। यह संरचना एक बुनियादी एजेंट के लिए आश्चर्यजनक रूप से प्रभावी है और आपके एजेंट को नए कौशल सिखाने के लिए और अधिक elif ब्लॉक्स जोड़कर इसका विस्तार करना आसान है।

कमांड प्रोसेसिंग को स्केल करना

हालांकि if/elif चेन्स कुछ कमांड्स के लिए काम करती हैं, लेकिन जैसे-जैसे आपके एजेंट की क्षमताएं बढ़ती हैं, वे बोझिल हो जाती हैं। अधिक स्केलेबल आर्किटेक्चर के लिए, आप इस लॉजिक को एक डिक्शनरी या क्लास-बेस्ड सिस्टम में रीफैक्टर (refactor) कर सकते हैं। वास्तव में उन्नत इरादे की पहचान (intent recognition) के लिए, डेवलपर्स नेचुरल लैंग्वेज अंडरस्टैंडिंग (NLU) मॉडल का उपयोग करते हैं। ये मॉडल वाक्य बनाने के तरीकों में भिन्नता को समझ सकते हैं और अनुरोध से विशिष्ट एंटिटीज़ (जैसे नाम या दिनांक) निकाल सकते हैं, जिससे बातचीत अधिक लचीली हो जाती है। विभिन्न भाषाओं में उपयोगकर्ताओं का समर्थन करने के लिए आप pre-trained multilingual models का भी पता लगा सकते हैं।

स्टेप 5: मुख्य एप्लीकेशन में सब कुछ एकीकृत करना

हमने व्यक्तिगत घटक बना लिए हैं: कान (listener.py), मुंह (speaker.py), और दिमाग (processor.py)। अब, आइए उन्हें एक सुसंगत एप्लीकेशन में जोड़ते हैं। यह अंतिम स्क्रिप्ट एंट्री पॉइंट के रूप में काम करेगी, जो एक मुख्य लूप चलाएगी जो लगातार सुनती है, प्रोसेस करती है और जवाब देती है।

अपनी प्रोजेक्ट डायरेक्टरी में एक अंतिम फ़ाइल, main.py बनाएं।

PYTHON

import listener<br>import speaker<br>import processor<p></p>
<p>def main():<br>"""Main function to run the voice agent."""<br>speaker.configure_voice()<br>speaker.speak("Hello, I am your voice assistant. How can I assist you?")</p>
<pre><code>while True:
    command = listener.listen_for_command()

    if command:
        response = processor.process_command(command)
        speaker.speak(response)

        if "goodbye" in command or "exit" in command:
            break
</code></pre>

import listener<br>import speaker<br>import processor<p></p>
<p>def main():<br>"""Main function to run the voice agent."""<br>speaker.configure_voice()<br>speaker.speak("Hello, I am your voice assistant. How can I assist you?")</p>
<pre><code>while True:
    command = listener.listen_for_command()

    if command:
        response = processor.process_command(command)
        speaker.speak(response)

        if "goodbye" in command or "exit" in command:
            break
</code></pre>

import listener<br>import speaker<br>import processor<p></p>
<p>def main():<br>"""Main function to run the voice agent."""<br>speaker.configure_voice()<br>speaker.speak("Hello, I am your voice assistant. How can I assist you?")</p>
<pre><code>while True:
    command = listener.listen_for_command()

    if command:
        response = processor.process_command(command)
        speaker.speak(response)

        if "goodbye" in command or "exit" in command:
            break
</code></pre>

यह स्क्रिप्ट हमारे ऑर्केस्ट्रा के कंडक्टर की तरह है। यह हमारे तीन मॉड्यूल्स को इम्पोर्ट करती है और मुख्य लूप चलाती है। while True लूप के अंदर, यह listener.listen_for_command() को कॉल करती है, परिणाम को processor.process_command() पर भेजती है, और मिले हुए जवाब को speaker.speak() को भेजती है। हमने प्रोग्राम को शालीनता से समाप्त करने के लिए 'goodbye' या 'exit' की जांच भी शामिल की है।

अपने पूरी तरह से कार्यात्मक वॉयस एजेंट को चलाने के लिए, सक्रिय वर्चुअल एनवायरनमेंट के साथ अपना टर्मिनल खोलें, और चलाएं:

BASH

python main.py

python main.py

python main.py

आपका एजेंट आपका स्वागत करेगा। इसे "what is the time?" या "open google" जैसे कमांड देने का प्रयास करें। बधाई हो, आपने पायथन में सफलतापूर्वक एक वॉयस एजेंट बना लिया है!

अपने वॉयस एजेंट के लिए सही API का चयन करना

SpeechRecognition लाइब्रेरी कई APIs का समर्थन करती है, और आपका चयन आपके एजेंट के प्रदर्शन, लागत और क्षमताओं को महत्वपूर्ण रूप से प्रभावित करेगा। हमारा उदाहरण गूगल वेब स्पीच एपीआई (Google Web Speech API) का उपयोग करता है, जो त्वरित प्रोजेक्ट्स के लिए सुविधाजनक है लेकिन इसकी अपनी सीमाएं हैं।

एक प्रोडक्शन एप्लीकेशन के लिए, आप संभवतः मुफ्त वेब स्पीच एपीआई से गूगल क्लाउड स्पीच, एडब्ल्यूएस ट्रांसक्राइब (AWS Transcribe), या किसी विशेष प्रदाता जैसी अधिक शक्तिशाली सेवा पर स्विच करेंगे। ये सेवाएं उच्च सटीकता, बेहतर शोर नियंत्रण और स्पीकर डायराइजेशन (speaker diarization) जैसी सुविधाएं प्रदान करती हैं। अपनी विशिष्ट आवश्यकताओं के लिए choosing the best speech-to-text API चुनते समय विकल्पों पर शोध और तुलना करना आपके समय के अनुकूल होगा।

सामान्य गलतियाँ और समस्या निवारण (Troubleshooting)

अपना पहला वॉयस एजेंट बनाना फायदेमंद है, लेकिन आपको कुछ सामान्य समस्याओं का सामना करना पड़ सकता है। यहाँ कुछ सबसे लगातार समस्याओं के समाधान दिए गए हैं।

• AttributeError: 'NoneType' object has no attribute 'lower': यह त्रुटि आमतौर पर main.py में तब होती है जब listen_for_command() कुछ भी वापस नहीं करता क्योंकि यह ऑडियो को समझने में विफल रहा। हमारा कोड एक खाली स्ट्रिंग लौटाकर इसे संभालता है, लेकिन हमेशा सुनिश्चित करें कि आपका मुख्य लूप प्रोसेसिंग से पहले जांचता है कि कमांड मान्य है या नहीं (जैसे, if command:)।

• खराब पहचान सटीकता: यदि एजेंट लगातार आपको गलत समझता है, तो इसका कारण अक्सर ऑडियो गुणवत्ता होती है। बैकग्राउंड का शोर कम करें, सुनिश्चित करें कि आपका माइक्रोफ़ोन अच्छी तरह से स्थित है, और स्पष्ट रूप से बोलें। r.adjust_for_ambient_noise() फ़ंक्शन भी बहुत महत्वपूर्ण है; इसे कैलिब्रेट करने के लिए कुछ पल का मौन दें।

• Could not request results... त्रुटि: यह RequestError लगभग हमेशा नेटवर्क समस्या का संकेत देती है। अपना इंटरनेट कनेक्शन जांचें। ऐसा तब भी हो सकता है जब किसी API का मुफ़्त दैनिक उपयोग कोटा समाप्त हो गया हो।

• TTS आवाज रोबोट जैसी लगती है: pyttsx3 की डिफ़ॉल्ट ऑफ़लाइन आवाजें कार्यात्मक हैं लेकिन बहुत प्राकृतिक नहीं हैं। यह अंतर्निहित OS-स्तरीय TTS इंजन की एक सीमा है। अधिक जीवंत भाषण प्राप्त करने के लिए, आपको क्लाउड-आधारित TTS API को एकीकृत करना होगा। इसके लिए कई Python packages for realistic text-to-speech मदद कर सकते हैं।

सारांश और अगले कदम

हमने पायथन में एक कार्यात्मक वॉयस एजेंट को सफलतापूर्वक बनाया है, कार्य को प्रबंधनीय घटकों में विभाजित किया है: एक लिसनर, एक स्पीकर, एक प्रोसेसर और एक मुख्य एप्लीकेशन लूप। अब आपके पास अधिक उन्नत और व्यक्तिगत वॉयस असिस्टेंट बनाने के लिए एक ठोस आधार है।

वॉयस एआई में आपकी यात्रा अभी शुरू हुई है। आगे कहाँ जाना है, इसके लिए यहाँ कुछ विचार दिए गए हैं:

संभावित संवर्द्धन (Potential Enhancements):

• कमांड सेट का विस्तार करें: अपने processor.py मॉड्यूल में अधिक कार्यक्षमता जोड़ें। आप मौसम की जानकारी प्राप्त करने, समाचार की सुर्खियां पढ़ने, या स्मार्ट होम उपकरणों को नियंत्रित करने के लिए अन्य APIs के साथ एकीकृत कर सकते हैं।

• एक वेक वर्ड (Wake Word) लागू करें: सामान्य कमांड्स को प्रोसेस करना शुरू करने से पहले एक विशिष्ट वेक वर्ड (जैसे 'हे, असिस्टेंट') को लगातार सुनने के लिए लिसनर को संशोधित करें।

• बेहतर TTS आवाज में अपग्रेड करें: उपयोगकर्ता के अनुभव पर एजेंट की आवाज का बहुत बड़ा प्रभाव पड़ता है। अपने एजेंट को अधिक पेशेवर आवाज देने के लिए क्लाउड-आधारित TTS सेवाओं का पता लगाएं। यह creating human-like AI voices की कुंजी है।

• NLU को एकीकृत करें: नेचुरल लैंग्वेज अंडरस्टैंडिंग सेवा का उपयोग करके साधारण कीवर्ड मैचिंग से आगे बढ़ें। यह आपके एजेंट को अधिक जटिल उपयोगकर्ता अनुरोधों को संभालने की अनुमति देगा, जिससे यह काफी अधिक बुद्धिमान बन जाएगा।

वॉयस एआई का क्षेत्र गतिशील और रोमांचक है। इस गाइड का अनुसरण करके, आपने एक महत्वपूर्ण पहला कदम उठाया है और अब आप इसकी विशाल संभावनाओं का पता लगाने के लिए आवश्यक कौशल से लैस हैं।