Ever wished you had a smart assistant that truly understood you, wasn't tied to big tech companies, and perhaps even knew where to find the best kottu in Colombo? Well, good news, machan! You can build one yourself!
Forget expensive smart speakers with limited customization. This guide from SL Build LK will show you how to combine the mighty Raspberry Pi with the incredible power of OpenAI's ChatGPT to create your very own, privacy-focused AI assistant right here in Sri Lanka. Get ready to dive into a super cool DIY project!
Why Build Your Own AI Assistant?
In a world full of smart devices, why go through the hassle of building your own? The answer is simple: control, customization, and a whole lot of learning!
Imagine an assistant that doesn't just play music but can tell you the latest fuel prices in Sri Lanka, help you find the next bus to Kandy, or even draft an email in Sinhala. The possibilities are endless when you're the architect.
- Privacy First: You control your data. No big corporations listening in or selling your information.
- Endless Customization: Tailor its voice, wake word, and even its personality. Want a friendly, sarcastic, or super-efficient assistant? You decide!
- Learn & Grow: This project is a fantastic way to learn about Python, Linux, AI APIs, and electronics. It's a skill builder for the future!
- Cost-Effective: Once you have the hardware, the API costs are minimal, often cheaper than buying a branded smart speaker.
- Local Relevance: Program it to understand and respond to specific Sri Lankan queries and contexts.
The Brains & Brawn: Raspberry Pi & ChatGPT
Our DIY AI assistant relies on a powerful duo: the compact Raspberry Pi for hardware and OpenAI's ChatGPT for intelligence.
The Raspberry Pi is a tiny, credit-card-sized computer loved by hobbyists and professionals alike. It’s incredibly versatile, affordable, and perfect for always-on projects like this. Think of it as the nervous system and body of your AI assistant.
ChatGPT, powered by OpenAI, is a large language model (LLM) capable of understanding and generating human-like text. It’s the "brain" that processes your spoken questions, understands their meaning, and formulates intelligent responses. We'll be using its API to connect to our Pi.
Choosing Your Raspberry Pi
While many Raspberry Pi models can work, some are better suited for the computational demands of an AI assistant. Here’s a quick comparison:
| Feature | Raspberry Pi 3B+ | Raspberry Pi 4 (2GB/4GB) | Raspberry Pi 5 |
|---|---|---|---|
| Processor | Quad-core Cortex-A53 (1.4GHz) | Quad-core Cortex-A72 (1.5GHz/1.8GHz) | Quad-core Cortex-A76 (2.4GHz) |
| RAM | 1GB LPDDR2 | 2GB/4GB LPDDR4 | 4GB/8GB LPDDR4X |
| Connectivity | Wi-Fi, Bluetooth 4.2 | Dual-band Wi-Fi, Bluetooth 5.0 | Dual-band Wi-Fi 6, Bluetooth 5.0 |
| Performance for AI | Acceptable, might be slow | Good balance of cost/performance | Excellent, fastest option |
| Price (Approx. LKR) | LKR 10,000 - 15,000 | LKR 15,000 - 25,000 | LKR 30,000+ |
For a smooth experience, we recommend a Raspberry Pi 4 (4GB RAM minimum) or ideally a Raspberry Pi 5. The extra processing power will make a noticeable difference when handling speech-to-text and text-to-speech tasks.
What You'll Need: The Shopping List
Before we start coding, let's gather all the necessary components. Most of these can be found at local electronics stores in Pettah, or online retailers like Techzilla.lk or Takas.lk.
- Raspberry Pi: Raspberry Pi 4 (4GB or 8GB) or Raspberry Pi 5.
- Micro SD Card: 16GB or 32GB (Class 10 or higher) pre-loaded with Raspberry Pi OS.
- Power Supply: Official Raspberry Pi USB-C power supply (5V, 3A for Pi 4; 5V, 5A for Pi 5).
- Microphone: A USB microphone is easiest to set up. Look for an inexpensive but decent quality one.
- Speaker: Any USB-powered or 3.5mm jack speaker will work. A small Bluetooth speaker can also be connected.
- Keyboard & Mouse: For initial setup (can be removed later).
- Monitor with HDMI Cable: For initial setup (can be removed later).
- Internet Connection: Via Wi-Fi or Ethernet.
- OpenAI API Key: You'll need to create an account on OpenAI Platform and generate an API key. Be aware of their pricing – there's usually a free tier for new users.
The Build Process: Your Step-by-Step Guide
This is where the magic happens! We'll walk you through setting up your Pi and writing the Python code to bring your AI assistant to life.
Step 1: Set Up Your Raspberry Pi
First, get your Raspberry Pi up and running. If you're a beginner, check out our previous guides on flashing Raspberry Pi OS.
- Install Raspberry Pi OS: Use the Raspberry Pi Imager tool to flash the latest Raspberry Pi OS (64-bit Lite or Desktop) onto your SD card.
- Initial Boot & Configuration: Connect your Pi to a monitor, keyboard, and mouse. Boot it up, connect to Wi-Fi, and perform all necessary updates via the terminal:
sudo apt update && sudo apt upgrade -y - Enable SSH (Optional but Recommended): For headless operation, enable SSH via `sudo raspi-config` under Interface Options.
Step 2: Install Python & Dependencies
Python is pre-installed on Raspberry Pi OS. Now, we need to install the libraries that handle speech recognition, text-to-speech, and communication with OpenAI.
- Install Virtual Environment (Recommended): This keeps your project's dependencies separate.
sudo apt install python3-venv python3 -m venv ai_assistant_env source ai_assistant_env/bin/activate - Install Python Libraries:
pip install openai speechrecognition pyaudio gtts playsoundNote: `pyaudio` might require `portaudio19-dev` on some systems: `sudo apt-get install portaudio19-dev python3-pyaudio`
Step 3: Obtain Your OpenAI API Key
Head over to OpenAI's API Key page, log in or sign up, and generate a new secret key. Keep this key safe and **never share it publicly!**
Store your API key as an environment variable or in a separate configuration file for security. For simplicity in this guide, we'll put it directly into the script, but for production, environment variables are better.
Step 4: Write the Python Script (ai_assistant.py)
This is the core logic of your assistant. Create a new file named `ai_assistant.py` and paste the following code. We'll break it down.
import speech_recognition as sr
import openai
from gtts import gTTS
import os
import playsound
import time
# --- Configuration ---
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY_HERE" # REPLACE WITH YOUR ACTUAL KEY
WAKE_WORD = "hey buddy" # Customize your wake word
openai.api_key = OPENAI_API_KEY
# --- Configuration End ---
def speak(text):
"""Converts text to speech and plays it."""
print(f"Assistant: {text}")
try:
tts = gTTS(text=text, lang='en', slow=False)
filename = "response.mp3"
tts.save(filename)
playsound.playsound(filename)
os.remove(filename) # Clean up the audio file
except Exception as e:
print(f"Error in text-to-speech: {e}")
def listen_for_wake_word(recognizer, source):
"""Listens for the wake word without sending to OpenAI."""
print(f"Listening for '{WAKE_WORD}'...")
try:
audio = recognizer.listen(source, timeout=5, phrase_time_limit=3)
text = recognizer.recognize_google(audio).lower()
print(f"Heard: {text}")
if WAKE_WORD in text:
speak("How can I help you?")
return True
except sr.WaitTimeoutError:
pass # No speech detected in time
except sr.UnknownValueError:
pass # Google Speech Recognition could not understand audio
except sr.RequestError as e:
print(f"Could not request results from Google Speech Recognition service; {e}")
return False
def get_audio_input(recognizer, source):
"""Listens for user's question and converts it to text."""
print("Listening for your question...")
try:
audio = recognizer.listen(source, timeout=8, phrase_time_limit=6)
text = recognizer.recognize_google(audio)
print(f"You said: {text}")
return text
except sr.WaitTimeoutError:
speak("I didn't hear anything. Please try again.")
return None
except sr.UnknownValueError:
speak("Sorry, I could not understand what you said.")
return None
except sr.RequestError as e:
speak(f"Could not request results from Google Speech Recognition service; {e}")
return None
def get_chatgpt_response(prompt):
"""Sends the user's prompt to ChatGPT and returns the response."""
try:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # You can use gpt-4 or other models if available
messages=[
{"role": "system", "content": "You are a helpful AI assistant from Sri Lanka. Provide concise and relevant information, especially when it comes to local context."},
{"role": "user", "content": prompt}
]
)
return response.choices[0].message.content
except openai.APIError as e:
print(f"OpenAI API Error: {e}")
return "I'm having trouble connecting to my brain. Please try again later."
except Exception as e:
print(f"An unexpected error occurred with OpenAI: {e}")
return "I encountered an error. Can you please rephrase?"
if __name__ == "__main__":
r = sr.Recognizer()
with sr.Microphone() as source:
r.adjust_for_ambient_noise(source) # Adjust for background noise once
speak("AI assistant started. Listening for wake word.")
while True:
if listen_for_wake_word(r, source):
user_question = get_audio_input(r, source)
if user_question:
response_text = get_chatgpt_response(user_question)
speak(response_text)
time.sleep(0.5) # Prevent high CPU usage by looping too fast
Code Breakdown:
- `speak(text)`: Uses Google Text-to-Speech (gTTS) to convert text into an audio file, then plays it using `playsound`.
- `listen_for_wake_word()`: Continuously listens for your defined wake word (e.g., "Hey Buddy"). It uses Google Speech Recognition for this.
- `get_audio_input()`: Once the wake word is detected, this function listens for your actual question.
- `get_chatgpt_response()`: Takes your question, sends it to the OpenAI API (using `gpt-3.5-turbo` model), and receives a text response. Notice the "system" role message – this helps guide ChatGPT to act as a "helpful AI assistant from Sri Lanka."
- `main` loop: The heart of the script. It continuously listens for the wake word, then for your query, gets a ChatGPT response, and speaks it back to you.
Step 5: Run Your AI Assistant!
Save the `ai_assistant.py` file. Make sure your microphone and speakers are connected and working.
Open your terminal, navigate to the directory where you saved the script, activate your virtual environment, and run it:
cd /path/to/your/script
source ai_assistant_env/bin/activate
python ai_assistant.py
Now, say your wake word ("Hey Buddy") followed by your question! Try asking, "What's the best place for a beach holiday in Sri Lanka?" or "Tell me about the history of Sigiriya."
Customizing Your Sri Lankan AI Buddy
Now that you have a functional assistant, let's make it truly yours and add some local flavour!
- Change the Wake Word: Edit the `WAKE_WORD` variable in the script. Maybe "Machan AI" or "Lanka Talk"?
- Personalize the Voice: `gTTS` has limited voice options. For more advanced voices, you could explore other text-to-speech libraries or APIs like Google Cloud Text-to-Speech (requires a Google Cloud account).
- Add Local Knowledge: The "system" message in `get_chatgpt_response` is crucial. Expand it to guide ChatGPT further. For example: "You are a helpful AI assistant from Sri Lanka. When asked about local topics like food, travel, or news, prioritize Sri Lankan context. Always mention famous Sri Lankan dishes if relevant."
- Integrate Local APIs (Advanced): For real-time local data (like bus schedules, specific news headlines, or even local weather), you'd need to integrate additional APIs. This involves more Python coding to fetch data from sources like OpenWeatherMap for Colombo's weather or local news RSS feeds.
- Home Automation: Connect your Raspberry Pi to smart home devices (e.g., using Home Assistant) to control lights, fans, or even your smart kettle with voice commands!
Remember, your AI assistant is a project that can constantly evolve. Keep experimenting, keep learning, and make it uniquely Sri Lankan!
Conclusion
Congratulations, tech warrior! You've successfully built your very own AI assistant using a Raspberry Pi and ChatGPT. This project not only gives you a powerful, customized tool but also a deeper understanding of how AI and embedded systems work together.
The journey doesn't end here. Keep tweaking, keep improving, and let your imagination run wild. What local features will you add next?
Did you enjoy this guide? Don't forget to subscribe to SL Build LK for more awesome DIY projects, tech reviews, and troubleshooting tips. Share your custom AI assistant builds in the comments below – we'd love to see what you've created!
0 Comments