🤖 Crée ton propre Jarvis en Python ! Un assistant vocal pour ton PC

import requests
import gradio as gr
import speech_recognition as sr
import pyttsx3
import re
import threading
import time

# Endpoint de l'API locale Ollama
OLLAMA_URL = "http://localhost:11434/api/generate"

# Initialisation du moteur de synthèse vocale (Text-to-Speech)
engine = pyttsx3.init()
engine.setProperty('rate', 170)  # Vitesse de la parole

# Variables pour le contrôle vocal
speaking_thread = None
stop_speaking = False

# Mémoire de la conversation
conversation_history = ""
last_interaction_time = time.time()
CONVERSATION_TIMEOUT = 180  # On oublie la conversation après 3 minutes d'inactivité

def speak_text(text):
    """ Fait parler l'assistant dans un thread séparé. """
    global stop_speaking
    stop_speaking = False
    engine.say(text)
    try:
        # Boucle pour permettre l'interruption
        while not stop_speaking:
            engine.runAndWait()
            break
    except RuntimeError:
        # Évite un crash si on stoppe en plein milieu de la parole
        pass

def stop_speech():
    """ Arrête la parole de l'assistant. """
    global stop_speaking
    stop_speaking = True
    try:
        engine.stop()
    except Exception:
        pass

def ai_assistant(text):
    """
    Génère une réponse de l'assistant IA en utilisant l'historique de la conversation.
    """
    global conversation_history, last_interaction_time

    # Si on n'a pas parlé depuis longtemps, on réinitialise la mémoire
    if time.time() - last_interaction_time > CONVERSATION_TIMEOUT:
        print("🧹 Nouveau contexte (ancien effacé car inactif)")
        conversation_history = ""

    # On ajoute la nouvelle question à l'historique
    conversation_history += f"\nUtilisateur: {text}"

    # On construit le prompt pour l'IA
    prompt = f"""Tu es Jarvis, un assistant personnel intelligent.
Voici la conversation en cours : 

{conversation_history}

Réponds de manière concise et utile à la dernière question posée par l'utilisateur.
Réponse:"""
    
    payload = {
        "model": "deepseek-r1",
        "prompt": prompt,
        "stream": False,
    }
    
    # On envoie la requête à notre IA locale
    response = requests.post(OLLAMA_URL, json=payload)

    if response.status_code == 200:
        ai_response = response.json().get("response", "Désolé, je n'ai pas de réponse.")
        # Petit nettoyage pour enlever des balises non désirées
        cleaned_text = re.sub(r'<think>.*?</think>', '', ai_response, flags=re.DOTALL)

        # On sauvegarde la réponse de Jarvis dans l'historique
        conversation_history += f"\nJarvis: {cleaned_text}"
        last_interaction_time = time.time()

        # On lance la lecture vocale dans un thread pour ne pas bloquer le programme
        global speaking_thread
        speaking_thread = threading.Thread(target=speak_text, args=(cleaned_text,))
        speaking_thread.start()

        return ai_response
    else:
        return "Erreur: Impossible de contacter le serveur AI."
    
def listen_command():
    """ Écoute l'utilisateur via le microphone et retourne le texte. """
    recognizer = sr.Recognizer()
    microphone = sr.Microphone()
    
    with microphone as source:
        print("🎤 Écoute... (parlez, Jarvis attendra vos pauses)")
        recognizer.adjust_for_ambient_noise(source, duration=1)
        
        # Le temps de pause avant de considérer la phrase comme terminée
        recognizer.pause_threshold = 1.5  
        audio = recognizer.listen(source, phrase_time_limit=12)  
    
    try:
        command = recognizer.recognize_google(audio, language="fr-FR")
        print(f"👉 Vous avez dit: {command}")
        return command.lower()
    except sr.UnknownValueError:
        # Si la voix n'est pas comprise
        return ""
    except sr.RequestError:
        return "Erreur de service de reconnaissance vocale."

def is_stop_command(command: str) -> bool:
    """ Vérifie si la commande est une demande d'arrêt. """
    stop_keywords = ["jarvis stop", "stop jarvis", "arrête", "tais-toi", "silence"]
    return any(kw in command for kw in stop_keywords)


# === Le cœur du programme : la boucle infinie ===
while True:
    command = listen_command()

    # Priorité 1 : Vérifier si on doit l'arrêter de parler
    if is_stop_command(command):
        print("⏹️ Arrêt immédiat de la parole de Jarvis.")
        stop_speech()
        continue # On recommence à écouter

    # Priorité 2 : Vérifier si on l'appelle
    if "jarvis" in command:
        print("🔑 Mot-clé 'Jarvis' détecté. Traitement de la question...")
        response = ai_assistant(command)
        print(f"🤖 Réponse de l'assistant: {response}")

import requests # Pour envoyer des requêtes à l'IA
import speech_recognition as sr # Pour comprendre ce que tu dis
import pyttsx3 # Pour faire parler Jarvis
import threading # Pour que Jarvis parle sans bloquer le reste du script
# ... et quelques autres !

OLLAMA_URL = "http://localhost:11434/api/generate"
engine = pyttsx3.init()
engine.setProperty('rate', 170)

import requests # Pour envoyer des requêtes à l'IA
import speech_recognition as sr # Pour comprendre ce que tu dis
import pyttsx3 # Pour faire parler Jarvis
import threading # Pour que Jarvis parle sans bloquer le reste du script
# ... et quelques autres !

OLLAMA_URL = "http://localhost:11434/api/generate"
engine = pyttsx3.init()
engine.setProperty('rate', 170)

def ai_assistant(text):
    # ...
    prompt = f"""Tu es Jarvis... Voici la conversation en cours : {conversation_history}..."""
    # ...
    response = requests.post(OLLAMA_URL, json=payload)
    # ...

def listen_command():
    recognizer = sr.Recognizer()
    microphone = sr.Microphone()
    # ...
    command = recognizer.recognize_google(audio, language="fr-FR")
    # ...

while True:
    command = listen_command()
 
    if is_stop_command(command):
        # ...
        continue
 
    if "jarvis" in command:
        # ...