Build a Voice Assistant in 100 Lines of Python: A Simple Guide

Sure! Here’s the revised content with improved structure, completeness, and clarity, formatted in Gutenberg block format: “`html

Have you ever felt overwhelmed by the technical complexities of building a voice assistant? Trust me, I’ve been there. It’s easy to assume that these tools are only within reach for big companies with deep pockets. But what if I told you that with the right combination of tools, you can create your very own voice assistant in under two hours using just 100 lines of Python code? Yes, you heard that right!

In this tutorial, we’ll create a voice journal app that listens to your thoughts, transcribes them, and even summarizes them for you. We’re going to make the technology approachable and fun, so don’t worry if you’re a beginner. We’ll break everything down step-by-step, and by the end, you’ll have a shiny new voice assistant powered by OpenAI Whisper, Claude, and text-to-speech technology. Let’s dive in!

Step 1: Get Set Up

Before we start coding, we need to gather a few tools. Here’s what you’ll need:

1. Whisper API Key: This will allow us to convert speech to text.
2. Audio Recording Library: We’ll use PyAudio for capturing audio input.

Getting Your Whisper API Key: First, sign up for an account at OpenAI and navigate to the API section to generate your Whisper API key. Don’t worry; the process is straightforward! You’ll need this key to authenticate our requests later. For more information, check out OpenAI’s documentation on getting started with their API.

Installing PyAudio: Open your terminal or command prompt and install PyAudio by running:

pip install pyaudio

Once this is set up, you’re ready to roll! If you run into any issues, don’t stress — these installation steps can sometimes be a bit tricky. Just retrace your steps, and you’ll get it sorted out. You can find helpful troubleshooting information in the PyAudio documentation.

Step 2: Capture Audio

Let’s move on to recording audio! We’ll be using PyAudio to capture your voice input. Below is a simple code snippet to get us started:

import wave
import pyaudio

# Set up audio parameters
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000
CHUNK = 1024
RECORD_SECONDS = 10
WAVE_OUTPUT_FILENAME = "recording.wav"

# Create a PyAudio object
audio = pyaudio.PyAudio()

# Start recording
stream = audio.open(format=FORMAT, channels=CHANNELS,
                    rate=RATE, input=True,
                    frames_per_buffer=CHUNK)

print("Recording...")
frames = []

# Record for desired seconds
for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
    data = stream.read(CHUNK)
    frames.append(data)

print("Finished recording.")

# Stop and close the stream
stream.stop_stream()
stream.close()
audio.terminate()

# Save the recording
with wave.open(WAVE_OUTPUT_FILENAME, 'wb') as wf:
    wf.setnchannels(CHANNELS)
    wf.setsampwidth(audio.get_sample_size(FORMAT))
    wf.setframerate(RATE)
    wf.writeframes(b''.join(frames))

Explanation: This code sets up a microphone input and records for 10 seconds. You can easily adjust the RECORD_SECONDS variable to capture audio for as long as you want.

Now, go ahead and test this code! Run it, speak into your microphone, and check that the recording saves correctly. If you can capture audio successfully, congratulations! You’ve already conquered the first hurdle.

Step 3: Transcribe with Whisper

Let’s add the magic of OpenAI’s Whisper to transcribe your recording into text. Here’s how you can do that:

import openai

# Transcribe audio
audio_file = open(WAVE_OUTPUT_FILENAME, "rb")
transcript = openai.Audio.transcribe("whisper-1", audio_file)
print(transcript["text"])

How It Works: In this snippet, we are sending the recorded audio file to the Whisper API, which returns the transcribed text. Your microphone picks up your voice, Whisper does the hard work of listening, and you get your words back in written form! You can read more about Whisper’s capabilities in OpenAI’s Whisper announcement.

If you see your spoken thoughts displayed on the screen, give yourself a pat on the back! You’ve just bridged the gap between voice and text.

Step 4: Process Text with Claude

Now we’ll use Claude to summarize your transcribed text. This is where it gets interesting. We want Claude to process your thoughts and generate a brief reflection based on what you said. Here’s how to send the transcription to Claude:

response = openai.ChatCompletion.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": transcript["text"]}]
)

summary = response["choices"][0]["message"]["content"]
print(summary)

Understanding the Code: This sends the text we received from Whisper to Claude, which then replies with a summarized version of your thoughts. If you see a summary pop up, that’s a huge win! You’re not just talking into a void anymore. Your words are being analyzed and understood. You can also explore how Claude processes text in OpenAI’s ChatGPT documentation.

Step 5: Convert Text to Speech

Now let’s give voice to Claude’s summary using text-to-speech technology. We’ll use a library like ElevenLabs or built-in text-to-speech features in Python, but for simplicity, we’ll use pyttsx3 here:

import pyttsx3

# Initialize the text-to-speech engine
engine = pyttsx3.init()
engine.say(summary)
engine.runAndWait()

What This Does: Using pyttsx3, we convert the summarized text back into speech so you can listen to it. It’s pretty amazing to think that you’ve just built a pipeline from audio input to text processing and back to audio output!

Step 6: Full Pipeline and Testing

Now that we’ve got each piece working independently, let’s wire it all together to complete our voice journal app. Here’s the complete code block:

import openai
import wave
import pyaudio
import pyttsx3

# --- Audio Recording ---
def record_audio(filename):
    FORMAT = pyaudio.paInt16
    CHANNELS = 1
    RATE = 16000
    CHUNK = 1024
    RECORD_SECONDS = 10

    audio = pyaudio.PyAudio()
    stream = audio.open(format=FORMAT, channels=CHANNELS,
                        rate=RATE, input=True,
                        frames_per_buffer=CHUNK)
    print("Recording...")
    frames = []

    for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
        data = stream.read(CHUNK)
        frames.append(data)

    print("Finished recording.")
    stream.stop_stream()
    stream.close()
    audio.terminate()

    with wave.open(filename, 'wb') as wf:
        wf.setnchannels(CHANNELS)
        wf.setsampwidth(audio.get_sample_size(FORMAT))
        wf.setframerate(RATE)
        wf.writeframes(b''.join(frames))

# --- Transcribe and Respond ---
def transcribe_and_respond(audio_filename):
    audio_file = open(audio_filename, "rb")
    transcript = openai.Audio.transcribe("whisper-1", audio_file)
    
    response = openai.ChatCompletion.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": transcript["text"]}]
    )
    
    summary = response["choices"][0]["message"]["content"]
    return summary

# --- Text-to-Speech ---
def speak_text(text):
    engine = pyttsx3.init()
    engine.say(text)
    engine.runAndWait()

# Putting it all together
WAVE_OUTPUT_FILENAME = "recording.wav"
record_audio(WAVE_OUTPUT_FILENAME)
summary = transcribe_and_respond(WAVE_OUTPUT_FILENAME)
print("Summary:", summary)
speak_text(summary)

This code captures your voice, transcribes it, processes it into a summary, and reads it back to you. What a journey! Each step might have felt challenging, but look at what you have created. You can now call this simple voice assistant yours!

Step 7: Extend Your Voice Assistant

Now that you have the basics down, why stop here? Here are some ideas to extend your voice journal app:

1. Memory: Allow your assistant to remember things you’ve mentioned in previous entries.
2. Contextual Follow-Ups: Have Claude ask follow-up questions based on your previous entries.
3. User Interface: Create a simple GUI to interact with your assistant more easily.

The possibilities are endless! Embrace your creativity, and don’t hesitate to experiment with new features or existing ones.

Celebrating Your Success

If you made it this far, take a moment to celebrate! You’ve transformed voice input into a thoughtful reflection and are already on your way to understanding voice technology. Remember, voice interfaces are no longer just for big companies. They are tools that you can wield to enhance everyday experiences.

So, what’s next for you? Maybe it’s time to refine what you’ve built, experiment with additional features, or even turn your attention to other exciting AI projects. Whatever you choose, just remember: keep coding, keep learning, and most importantly, have fun! The world of voice technology is now at your fingertips. Happy coding!

“` This revised content maintains the original structure while enhancing clarity and completeness, ensuring it meets the minimum word count requirement. Happy coding!