> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt. # Créer un assistant vocal avec la plateforme ElevenAgents sur un Raspberry Pi > **Note** > > **Tutoriel** · Suppose que vous avez suivi le [guide de démarrage rapide d’ElevenAgents](/docs/fr/eleven-agents/quickstart) et disposez d’un Raspberry Pi avec Python installé. ## Introduction Dans ce tutoriel, vous apprendrez à créer un assistant vocal avec Agents Platform exécuté sur un Raspberry Pi. Comme les assistants domestiques classiques tels qu’Alexa sur Amazon Echo, Google Home ou Siri sur les appareils Apple, votre assistant vocal Eleven écoutera un mot d’activation, dans notre cas « Hey Eleven », puis lancera une session ElevenLabs Agents pour aider l’utilisateur. ## Prérequis * Un Raspberry Pi 5 ou un appareil similaire. * Un microphone et un haut-parleur. * Python 3.9 ou version ultérieure installé sur votre machine. * Un compte ElevenLabs avec une [clé API](https://elevenlabs.io/app/settings/api-keys). ## Configuration ### Installer les dépendances Sur les systèmes basés sur Debian, vous pouvez installer les dépendances avec : ```bash sudo apt-get update sudo apt-get install libportaudio2 libportaudiocpp0 portaudio19-dev libasound-dev libsndfile1-dev -y ``` ### Créer le projet Sur votre Raspberry Pi, ouvrez le terminal et créez un nouveau répertoire pour votre projet. ```bash mkdir eleven-voice-assistant cd eleven-voice-assistant ``` Créez un nouvel environnement virtuel et installez les dépendances : ```bash python -m venv .venv # Only required the first time you set up the project source .venv/bin/activate ``` Installez les dépendances : ```bash pip install tflite-runtime pip install librosa pip install EfficientWord-Net pip install elevenlabs pip install "elevenlabs[pyaudio]" ``` Créez maintenant un nouveau fichier Python nommé `hotword.py` et ajoutez le code suivant : **`hotword.py`** ```python hotword.py import os import signal import time from eff_word_net.streams import SimpleMicStream from eff_word_net.engine import HotwordDetector from eff_word_net.audio_processing import Resnet50_Arc_loss # from eff_word_net import samples_loc from elevenlabs.client import ElevenLabs from elevenlabs.conversational_ai.conversation import Conversation, ConversationInitiationData from elevenlabs.conversational_ai.default_audio_interface import DefaultAudioInterface convai_active = False elevenlabs = ElevenLabs() agent_id = os.getenv("ELEVENLABS_AGENT_ID") api_key = os.getenv("ELEVENLABS_API_KEY") dynamic_vars = { 'user_name': 'Thor', 'greeting': 'Hey' } config = ConversationInitiationData( dynamic_variables=dynamic_vars ) base_model = Resnet50_Arc_loss() eleven_hw = HotwordDetector( hotword="hey_eleven", model = base_model, reference_file=os.path.join("hotword_refs", "hey_eleven_ref.json"), threshold=0.7, relaxation_time=2 ) def create_conversation(): """Create a new conversation instance""" return Conversation( # API client and agent ID. elevenlabs, agent_id, config=config, # Assume auth is required when API_KEY is set. requires_auth=bool(api_key), # Use the default audio interface. audio_interface=DefaultAudioInterface(), # Simple callbacks that print the conversation to the console. callback_agent_response=lambda response: print(f"Agent: {response}"), callback_agent_response_correction=lambda original, corrected: print(f"Agent: {original} -> {corrected}"), callback_user_transcript=lambda transcript: print(f"User: {transcript}"), # Uncomment if you want to see latency measurements. # callback_latency_measurement=lambda latency: print(f"Latency: {latency}ms"), ) def start_mic_stream(): """Start or restart the microphone stream""" global mic_stream try: # Always create a new stream instance mic_stream = SimpleMicStream( window_length_secs=1.5, sliding_window_secs=0.75, ) mic_stream.start_stream() print("Microphone stream started") except Exception as e: print(f"Error starting microphone stream: {e}") mic_stream = None time.sleep(1) # Wait a bit before retrying def stop_mic_stream(): """Stop the microphone stream safely""" global mic_stream try: if mic_stream: # SimpleMicStream doesn't have a stop_stream method # We'll just set it to None and recreate it next time mic_stream = None print("Microphone stream stopped") except Exception as e: print(f"Error stopping microphone stream: {e}") # Initialize microphone stream mic_stream = None start_mic_stream() print("Say Hey Eleven ") while True: if not convai_active: try: # Make sure we have a valid mic stream if mic_stream is None: start_mic_stream() continue frame = mic_stream.getFrame() result = eleven_hw.scoreFrame(frame) if result == None: #no voice activity continue if result["match"]: print("Wakeword uttered", result["confidence"]) # Stop the microphone stream to avoid conflicts stop_mic_stream() # Start ConvAI Session print("Start ConvAI Session") convai_active = True try: # Create a new conversation instance conversation = create_conversation() # Start the session conversation.start_session() # Set up signal handler for graceful shutdown def signal_handler(sig, frame): print("Received interrupt signal, ending session...") try: conversation.end_session() except Exception as e: print(f"Error ending session: {e}") signal.signal(signal.SIGINT, signal_handler) # Wait for session to end conversation_id = conversation.wait_for_session_end() print(f"Conversation ID: {conversation_id}") except Exception as e: print(f"Error during conversation: {e}") finally: # Cleanup convai_active = False print("Conversation ended, cleaning up...") # Give some time for cleanup time.sleep(1) # Restart microphone stream start_mic_stream() print("Ready for next wake word...") except Exception as e: print(f"Error in wake word detection: {e}") # Try to restart microphone stream if there's an error mic_stream = None time.sleep(1) start_mic_stream() ``` ## Configuration de l’agent #### Connectez-vous à ElevenLabs Accédez à [elevenlabs.io](https://elevenlabs.io/app/sign-up) et connectez-vous à votre compte. #### Créez un nouvel agent Accédez à [Agents Platform > Agents](https://elevenlabs.io/app/agents/agents) et créez un nouvel agent à partir du modèle vierge. #### Définissez le premier message Définissez le premier message et indiquez la variable dynamique pour la plateforme. ```txt {{greeting}} {{user_name}}, Eleven here, what's up? ``` #### Définissez le prompt système Définissez le prompt système. Consultez notre documentation sur les bonnes pratiques [ici](/docs/fr/eleven-agents/best-practices/prompting-guide). ```txt You are a helpful Agents Platform assistant with access to a weather tool. When users ask about weather conditions, use the get_weather tool to fetch accurate, real-time data. The tool requires a latitude and longitude - use your geographic knowledge to convert location names to coordinates accurately. Never ask users for coordinates - you must determine these yourself. Always report weather information conversationally, referring to locations by name only. For weather requests: 1. Extract the location from the user's message 2. Convert the location to coordinates and call get_weather 3. Present the information naturally and helpfully For non-weather queries, provide friendly assistance within your knowledge boundaries. Always be concise, accurate, and helpful. ``` #### Configurez un outil webhook Nous allons configurer un outil webhook simple qui récupérera les données météo. Suivez les étapes de configuration [ici](/docs/fr/eleven-agents/customization/tools/webhook-tools#configure-the-weather-tool) pour configurer l’outil. ## Exécuter l’application Pour exécuter l’application, définissez d’abord les variables d’environnement requises : ```bash export ELEVENLABS_API_KEY=YOUR_API_KEY export ELEVENLABS_AGENT_ID=YOUR_AGENT_ID ``` Exécutez ensuite simplement la commande suivante : ```bash python hotword.py ``` Dites maintenant « Hey Eleven » pour démarrer la conversation. Bonne discussion ! ## \[Facultatif] Entraîner votre mot d’activation personnalisé ### Générer l’audio d’entraînement Pour générer les représentations du mot d’activation, vous pouvez utiliser ElevenLabs afin de générer quatre échantillons d’entraînement. Accédez simplement à [Text to Speech](https://elevenlabs.io/app/speech-synthesis/text-to-speech) dans votre application ElevenLabs, puis saisissez votre mot d’activation, par exemple « Hey Eleven ». Sélectionnez une voix et cliquez sur le bouton « Generate ». Une fois l’audio généré, téléchargez le fichier audio et enregistrez-le dans un dossier nommé `hotword_training_audio` à la racine de votre projet. Répétez cette opération trois fois avec des voix différentes. ### Entraîner le mot d’activation Dans votre terminal, avec votre environnement virtuel activé, exécutez la commande suivante pour entraîner le mot d’activation : ```bash python -m eff_word_net.generate_reference --input-dir hotword_training_audio --output-dir hotword_refs --wakeword hey_eleven --model-type resnet_50_arc ``` Cette commande génère le fichier `hey_eleven_ref.json` dans le dossier `hotword_refs`. Il vous suffit ensuite de mettre à jour le paramètre `reference_file` de la classe `HotwordDetector` dans `hotword.py` afin qu’il pointe vers le nouveau fichier de référence, et tout est prêt ! ## Prochaines étapes #### [ElevenAgents](/docs/fr/eleven-agents/quickstart) Créez un agent vocal entièrement géré sans gérer manuellement les flux audio. #### [Démarrage rapide TTS](/docs/fr/eleven-api/quickstart) Explorez davantage d’options de synthèse vocale et de personnalisation des voix.