Build a Private AI Voice Assistant with OpenClaw + Whisper

[Microphone / Audio File]
        ↓
[Whisper (local STT)]  ←── runs on your CPU/GPU
        ↓
[Transcribed Text]
        ↓
[OpenClaw Agent]       ←── memory + tools + skills
        ↓
[Text Response]
        ↓
[TTS (local or API)]   ←── optional: piper / macOS say
        ↓
[Speaker Output]

pip install faster-whisper

# Or with uv (recommended):
uv pip install faster-whisper

from faster_whisper import WhisperModel

# Use "base" for speed, "small" for accuracy, "large-v3" for best
model = WhisperModel("base", device="cpu", compute_type="int8")

segments, info = model.transcribe("your_audio.wav", beam_size=5)

for segment in segments:
    print(f"[{segment.start:.2f}s → {segment.end:.2f}s] {segment.text}")

import sounddevice as sd
import numpy as np
import scipy.io.wavfile as wavfile
from faster_whisper import WhisperModel
import tempfile, os

SAMPLE_RATE = 16000
DURATION = 8  # seconds to record

model = WhisperModel("base", device="cpu", compute_type="int8")

def record_and_transcribe():
    print("🎙️  Recording... (press Ctrl+C to stop early)")
    audio = sd.rec(
        int(DURATION * SAMPLE_RATE),
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32"
    )
    sd.wait()
    
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        wavfile.write(f.name, SAMPLE_RATE, audio)
        segments, _ = model.transcribe(f.name)
        text = " ".join(s.text for s in segments).strip()
        os.unlink(f.name)
    
    return text

if __name__ == "__main__":
    result = record_and_transcribe()
    print(f"\n📝 Transcribed: {result}")

import requests

OPENCLAW_URL = "http://localhost:3000"  # default OpenClaw port
OPENCLAW_TOKEN = "your-gateway-token"   # from openclaw gateway status

def ask_openclaw(text: str) -> str:
    """Send transcribed text to OpenClaw and get agent response."""
    resp = requests.post(
        f"{OPENCLAW_URL}/api/session/message",
        json={"message": text},
        headers={"Authorization": f"Bearer {OPENCLAW_TOKEN}"}
    )
    resp.raise_for_status()
    return resp.json().get("reply", "")

# Full pipeline
transcribed = record_and_transcribe()
print(f"You said: {transcribed}")

reply = ask_openclaw(transcribed)
print(f"OpenClaw: {reply}")

import subprocess

def speak(text: str, voice: str = "Samantha"):
    """Speak text using macOS built-in TTS."""
    # Remove markdown formatting
    clean = text.replace("**", "").replace("*", "").replace("`", "")
    subprocess.run(["say", "-v", voice, clean])

# Full voice loop
transcribed = record_and_transcribe()
reply = ask_openclaw(transcribed)
speak(reply)

# Install piper
pip install piper-tts

# Download a voice model (en_US-lessac-medium is excellent)
python -m piper --download-dir ./voices en_US-lessac-medium

# Use in Python
from piper import PiperVoice
import wave, io

voice = PiperVoice.load("./voices/en_US-lessac-medium.onnx")

def speak_piper(text: str):
    with io.BytesIO() as wav_io:
        with wave.open(wav_io, "wb") as wav_file:
            voice.synthesize(text, wav_file)
        # Play the audio
        import sounddevice as sd
        import soundfile as sf
        wav_io.seek(0)
        data, rate = sf.read(wav_io)
        sd.play(data, rate)
        sd.wait()

pip install openwakeword

from openwakeword.model import Model
import pyaudio, numpy as np

oww_model = Model(wakeword_models=["hey_jarvis"])  # or custom

def listen_for_wake_word():
    p = pyaudio.PyAudio()
    stream = p.open(rate=16000, channels=1, format=pyaudio.paInt16, input=True)
    
    print("👂 Listening for wake word...")
    while True:
        audio_chunk = np.frombuffer(stream.read(1280), dtype=np.int16)
        oww_model.predict(audio_chunk)
        
        for model_name, scores in oww_model.prediction_buffer.items():
            if scores[-1] > 0.5:  # confidence threshold
                print(f"🎙️ Wake word detected!")
                stream.stop_stream()
                return  # trigger your recording loop