Tutoriel : Créer un assistant vocal avec l’IA

Ce que vous allez construire dans ce tutoriel

Dans ce tutoriel, vous allez créer un assistant vocal fonctionnel qui écoute votre voix, transcrit vos paroles en texte, envoie ce texte à un modèle d’IA pour obtenir une réponse, puis prononce cette réponse à voix haute. Le projet utilise Python et trois composants principaux : l’API Whisper d’OpenAI pour la reconnaissance vocale (speech-to-text), l’API GPT pour le traitement intelligent, et la bibliothèque pyttsx3 ou gTTS pour la synthèse vocale (text-to-speech).

Prérequis techniques

Vous avez besoin de Python 3.9 ou supérieur installé sur votre machine, d’un microphone fonctionnel, et d’une clé API OpenAI (créez un compte sur platform.openai.com). Un budget de 5 dollars suffit largement pour développer et tester le projet. Créez un dossier de projet et un environnement virtuel avec les commandes suivantes dans votre terminal :

mkdir assistant-vocal
cd assistant-vocal
python -m venv venv
source venv/bin/activate  # Sur Windows : venv\Scripts\activate
pip install openai speechrecognition pyttsx3 pyaudio

La bibliothèque SpeechRecognition capture l’audio du microphone, pyaudio gère l’interface avec le matériel audio, et pyttsx3 fournit la synthèse vocale hors ligne. Si l’installation de pyaudio pose problème sur Windows, téléchargez le fichier .whl correspondant à votre version Python depuis le site gohlke.github.io et installez-le avec pip install PyAudio-xxx.whl.

Étape 1 : Capturer et transcrire la voix avec Whisper

La première brique de l’assistant est la reconnaissance vocale. L’API Whisper d’OpenAI est actuellement le modèle le plus précis pour transcrire la parole en texte, et il gère très bien le français et le wolof. Créez un fichier transcription.py avec le code suivant :

import speech_recognition as sr
from openai import OpenAI

client = OpenAI(api_key="votre-cle-api-ici")

def ecouter_microphone():
    recognizer = sr.Recognizer()
    with sr.Microphone() as source:
        print("Ajustement au bruit ambiant...")
        recognizer.adjust_for_ambient_noise(source, duration=1)
        print("Parlez maintenant :")
        audio = recognizer.listen(source, timeout=10, phrase_time_limit=30)
    return audio

def transcrire_audio(audio):
    # Sauvegarder l'audio en fichier WAV temporaire
    with open("temp_audio.wav", "wb") as f:
        f.write(audio.get_wav_data())
    
    # Envoyer à Whisper pour transcription
    with open("temp_audio.wav", "rb") as audio_file:
        transcription = client.audio.transcriptions.create(
            model="whisper-1",
            file=audio_file,
            language="fr"
        )
    return transcription.text

# Test
audio = ecouter_microphone()
texte = transcrire_audio(audio)
print(f"Vous avez dit : {texte}")

La fonction ecouter_microphone() active le micro, calibre le niveau de bruit ambiant pendant 1 seconde, puis enregistre votre voix jusqu’à 30 secondes ou jusqu’à une pause de silence. La fonction transcrire_audio() envoie l’enregistrement à l’API Whisper qui retourne le texte transcrit. Le paramètre language= »fr » force la transcription en français, ce qui améliore la précision.

Étape 2 : Traiter la requête avec GPT

Une fois le texte obtenu, il faut l’envoyer à un modèle de langage pour obtenir une réponse intelligente. Créez un fichier cerveau.py :

from openai import OpenAI

client = OpenAI(api_key="votre-cle-api-ici")

# Historique de conversation pour le contexte
historique = [
    {
        "role": "system",
        "content": "Tu es un assistant vocal intelligent et concis. "
                   "Tu réponds en français en 2-3 phrases maximum. "
                   "Tu es amical et utile."
    }
]

def obtenir_reponse(texte_utilisateur):
    historique.append({"role": "user", "content": texte_utilisateur})
    
    reponse = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=historique,
        max_tokens=150,
        temperature=0.7
    )
    
    texte_reponse = reponse.choices[0].message.content
    historique.append({"role": "assistant", "content": texte_reponse})
    
    return texte_reponse

Le modèle gpt-4o-mini offre un excellent rapport qualité/prix pour un assistant vocal. Le paramètre max_tokens=150 limite la longueur de la réponse pour qu’elle reste naturelle à l’oral. L’historique de conversation est conservé en mémoire pour que l’assistant puisse faire référence aux échanges précédents. Le prompt système définit le comportement : réponses courtes, en français, ton amical.

Étape 3 : La synthèse vocale (text-to-speech)

La dernière brique transforme la réponse textuelle en parole. Deux options s’offrent à vous. La bibliothèque pyttsx3 fonctionne hors ligne et ne nécessite aucune API. L’API TTS d’OpenAI produit une voix plus naturelle mais nécessite une connexion internet. Créez un fichier voix.py :

import pyttsx3

# Option 1 : Synthèse vocale hors ligne avec pyttsx3
def parler_hors_ligne(texte):
    engine = pyttsx3.init()
    # Régler la vitesse (120-200 mots/minute)
    engine.setProperty('rate', 160)
    # Régler le volume (0.0 à 1.0)
    engine.setProperty('volume', 0.9)
    # Sélectionner une voix française si disponible
    voices = engine.getProperty('voices')
    for voice in voices:
        if 'french' in voice.name.lower() or 'fr' in voice.id.lower():
            engine.setProperty('voice', voice.id)
            break
    engine.say(texte)
    engine.runAndWait()

# Option 2 : Synthèse vocale avec l'API OpenAI TTS
from openai import OpenAI
from pathlib import Path
import subprocess

client = OpenAI(api_key="votre-cle-api-ici")

def parler_openai(texte):
    speech_file = Path("reponse.mp3")
    response = client.audio.speech.create(
        model="tts-1",
        voice="nova",  # Voix féminine naturelle
        input=texte
    )
    response.stream_to_file(speech_file)
    # Lire le fichier audio
    subprocess.run(["ffplay", "-nodisp", "-autoexit", str(speech_file)],
                   capture_output=True)

La voix « nova » d’OpenAI TTS est particulièrement naturelle en français. Les alternatives sont « alloy », « echo », « fable », « onyx » et « shimmer ». Testez-les pour trouver celle qui convient le mieux à votre assistant. Pour la lecture du fichier MP3 généré, ffplay (inclus avec ffmpeg) est utilisé ici, mais vous pouvez aussi utiliser la bibliothèque pygame ou playsound.

Étape 4 : Assembler l’assistant complet

Créez le fichier principal assistant.py qui combine les trois modules :

from transcription import ecouter_microphone, transcrire_audio
from cerveau import obtenir_reponse
from voix import parler_hors_ligne  # ou parler_openai

def main():
    print("=== Assistant Vocal IA ===")
    print("Dites 'stop' ou 'au revoir' pour quitter.")
    print()
    
    while True:
        try:
            # 1. Écouter
            audio = ecouter_microphone()
            
            # 2. Transcrire
            texte = transcrire_audio(audio)
            print(f"Vous : {texte}")
            
            # Vérifier si l'utilisateur veut quitter
            if any(mot in texte.lower() for mot in ['stop', 'au revoir', 'quitter']):
                parler_hors_ligne("Au revoir et à bientôt !")
                print("Assistant arrêté.")
                break
            
            # 3. Obtenir la réponse IA
            reponse = obtenir_reponse(texte)
            print(f"Assistant : {reponse}")
            
            # 4. Prononcer la réponse
            parler_hors_ligne(reponse)
            
        except KeyboardInterrupt:
            print("\nAssistant arrêté.")
            break
        except Exception as e:
            print(f"Erreur : {e}")
            continue

if __name__ == "__main__":
    main()

Lancez l’assistant avec python assistant.py. Le programme entre dans une boucle : il écoute votre voix, la transcrit, envoie le texte à GPT, récupère la réponse, et la prononce. Dites « au revoir » pour arrêter le programme proprement.

Améliorations possibles

Pour aller plus loin, vous pouvez ajouter un mot d’activation (wake word) comme « Hey assistant » en utilisant la bibliothèque pvporcupine de Picovoice, qui détecte des mots-clés en local sans envoyer d’audio au cloud. Vous pouvez aussi connecter l’assistant à des services externes : lire la météo via l’API OpenWeatherMap, envoyer des messages WhatsApp via l’API Twilio, ou contrôler des appareils domotiques.

Pour réduire la latence, utilisez l’API Whisper en mode streaming (si disponible) ou la bibliothèque faster-whisper qui exécute Whisper en local sur votre machine avec des performances proches du temps réel. Le modèle « tiny » de Whisper est suffisant pour la plupart des commandes vocales courtes et fonctionne sur un processeur standard sans GPU.

Le coût total de fonctionnement de cet assistant avec les API OpenAI est d’environ 0,01 dollar par échange (transcription Whisper + génération GPT-4o-mini + synthèse TTS). Pour une utilisation intensive, la version locale avec faster-whisper et un LLM open source comme Mistral 7B via Ollama réduit le coût à zéro après l’investissement initial en matériel.