For AI agents: the complete documentation index is available at https://docs.ovhcloud.com/fr/llms.txt, the full documentation bundle is available at https://docs.ovhcloud.com/fr/llms-full.txt, and this page is available as Markdown at https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/ai-endpoints-voice-virtual-assistant.md.

AI Endpoints - Développer son assistant audio

Voir en Markdown

Créez un chatbot vocal en utilisant des APIs d'ASR, de LLM et de TTS en moins de 100 lignes de code

Info

AI Endpoints est couvert par les Conditions particulières OVHcloud Public Cloud (voir l’Annexe 10 – « Conditions spécifiques – AI Endpoints »).

Introduction

Imaginez disposer d'un assistant virtuel qui écoute votre voix, comprend vos questions et répond par des réponses vocales, en moins de 100 lignes de code. Grâce à AI Endpoints, c'est désormais facilement réalisable.

Objectif

Dans ce tutoriel, vous allez apprendre à créer un assistant vocal virtuel (Audio Virtual Assistant) pleinement fonctionnel qui :

  • Accepte une entrée vocale depuis un microphone
  • La transcrit à l'aide de l'ASR (Automatic Speech Recognition)
  • Traite la requête à l'aide d'un LLM (Large Language Models)
  • Répond à l'aide de la TTS (Text-To-Speech)

Tout ceci est réalisé en connectant les AI Endpoints comme des pièces de puzzle, vous permettant de construire votre assistant en moins de 100 lignes de code Python.

connect-ai-apis

Définitions

  • Automatic Speech Recognition (ASR) : technologie qui convertit le langage parlé en texte. L'ASR permet ici à votre assistant de comprendre l'entrée vocale.
  • Large Language Models (LLM) : modèles avancés entraînés pour comprendre le contexte et générer des réponses proches de celles d'un humain. Ici, les LLM prendront en charge la logique et répondront intelligemment à vos questions.
  • Text-To-Speech (TTS) : technologie qui convertit du texte écrit en audio parlé. Avec la TTS, votre assistant répondra avec une voix naturelle, complétant ainsi la boucle de conversation.

Prérequis

En pratique

Configurer l'environnement

Afin d'utiliser facilement les API d'AI Endpoints, créez un fichier .env pour stocker les variables d'environnement :

TTS_GRPC_ENDPOINT=nvr-tts-en-us.endpoints-grpc.kepler.ai.cloud.ovh.net:443
OVH_AI_ENDPOINTS_URL=https://oai.endpoints.kepler.ai.cloud.ovh.net/v1
OVH_AI_ENDPOINTS_ACCESS_TOKEN=<ai-endpoints-api-token>

Veillez à remplacer la valeur du token (OVH_AI_ENDPOINTS_ACCESS_TOKEN) par la vôtre. Si vous n'en avez pas encore, suivez les instructions du guide AI Endpoints - Premiers pas.

Dans ce tutoriel, nous utiliserons les modèles Whisper-Large-V3 et gpt-oss-120b. N'hésitez pas à choisir d'autres modèles disponibles dans le catalogue AI Endpoints.

Créez ensuite un fichier requirements.txt avec les bibliothèques suivantes :

openai==1.68.2
streamlit==1.36.0
streamlit-mic-recorder==0.0.8
nvidia-riva-client==2.15.1
python-dotenv==1.0.1

Lancez ensuite l'installation de ces dépendances :

pip install -r requirements.txt

Notez que Python 3.11 est utilisé dans ce tutoriel.

Importer les bibliothèques et variables nécessaires

Une fois cela fait, vous pouvez créer un fichier Python nommé audio-virtual-assistant-app.py, dans lequel vous importerez d'abord les bibliothèques Python comme suit :

import os
import numpy as np
from openai import OpenAI
import riva.client
from dotenv import load_dotenv
import streamlit as st
from streamlit_mic_recorder import mic_recorder

Après ces lignes, chargez et accédez aux variables d'environnement de votre fichier .env :

# access the environment variables from the .env file
load_dotenv()

TTS_GRPC_ENDPOINT = os.environ.get('TTS_GRPC_ENDPOINT')
OVH_AI_ENDPOINTS_URL = os.environ.get('OVH_AI_ENDPOINTS_URL')
OVH_AI_ENDPOINTS_ACCESS_TOKEN = os.environ.get('OVH_AI_ENDPOINTS_ACCESS_TOKEN')

Ensuite, définissez les clients qui seront utilisés pour interagir avec les modèles :

oai_client = OpenAI(
    base_url=OVH_AI_ENDPOINTS_URL,
    api_key=OVH_AI_ENDPOINTS_ACCESS_TOKEN
)

tts_client = riva.client.SpeechSynthesisService(
    riva.client.Auth(
        uri=TTS_GRPC_ENDPOINT,
        use_ssl=True,
        metadata_args=[["authorization", f"bearer {OVH_AI_ENDPOINTS_ACCESS_TOKEN}"]]
    )
)

💡 Vous êtes maintenant prêt à commencer à coder votre application web !

Transcrire la question d'entrée avec l'ASR

Créez d'abord la fonction d'Automatic Speech Recognition (ASR) afin de transcrire l'entrée du microphone en texte :

def asr_transcription(question, oai_client):
    return oai_client.audio.transcriptions.create(
        model="whisper-large-v3",
        file=question
    ).text

Dans cette fonction :

  • L'entrée audio est envoyée depuis l'enregistrement du microphone, sous le nom question.
  • Un appel API est effectué vers l'AI Endpoint d'ASR nommé whisper-large-v3.
  • Le texte de la réponse de transcription est renvoyé par la fonction.

🎉 Maintenant que vous disposez de cette fonction, vous êtes prêt à transcrire des fichiers audio.

Générer la réponse du LLM à la question d'entrée

Créez maintenant une fonction qui appelle le client LLM pour fournir des réponses aux questions :

def llm_answer(input, oai_client):
    response = oai_client.chat.completions.create(
                model="gpt-oss-120b", 
                messages=input,
                temperature=0,
                max_tokens=1024,
            )
    msg = response.choices[0].message.content

    return msg

Dans cette fonction :

  • La conversation/les messages sont récupérés en tant que paramètres.
  • Un appel est effectué vers l'endpoint LLM de chat completion, en utilisant le modèle gpt-oss-120b.
  • La réponse du modèle est extraite et le texte du message final est renvoyé.

⏳ Presque terminé ! Il ne reste plus qu'à implémenter la TTS pour transformer la réponse du LLM en paroles.

Renvoyer la réponse avec la TTS

Construisez ensuite la fonction de Text To Speech (TTS) afin de transformer la réponse écrite en réponse orale :

def tts_synthesis(response, tts_client):

    # set up config
    sample_rate_hz = 48000
    req = {
            "language_code"  : "en-US",                           # languages: en-US
            "encoding"       : riva.client.AudioEncoding.LINEAR_PCM ,
            "sample_rate_hz" : sample_rate_hz,                    # sample rate: 48KHz audio
            "voice_name"     : "English-US.Female-1"              # voices: `English-US.Female-1`, `English-US.Male-1`
    }

    # return response
    req["text"] = response
    synthesized_response = tts_client.synthesize(**req)
    
    return np.frombuffer(synthesized_response.audio, dtype=np.int16), sample_rate_hz

Dans cette fonction :

  • La réponse du LLM est récupérée.
  • Un appel est effectué vers l'AI Endpoint de TTS nommé nvr-tts-en-us.
  • L'échantillon audio et le taux d'échantillonnage sont renvoyés pour lire l'audio automatiquement.

⚡️ Vous y êtes presque ! La dernière étape consiste à construire votre application web, rendant votre solution facile à utiliser en quelques lignes de code.

Construire l'application de chat LLM avec Streamlit

Dans cette dernière étape, créez l'application de chatbot à l'aide de Streamlit, une bibliothèque Python open source permettant de créer rapidement des interfaces utilisateur pour des modèles de Machine Learning et des démonstrations. Voici un exemple de code fonctionnel :

# streamlit interface
with st.container():
    st.title("💬 Audio Virtual Assistant Chatbot")

with st.container(height=600):
    messages = st.container()

    if "messages" not in st.session_state:
        st.session_state["messages"] = [{"role": "system", "content": "Hello, I'm AVA!", "avatar":"🤖"}]

    for msg in st.session_state.messages:
        messages.chat_message(msg["role"], avatar=msg["avatar"]).write(msg["content"])

with st.container():

    placeholder = st.empty()
    _, recording = placeholder.empty(), mic_recorder(
            start_prompt="START RECORDING YOUR QUESTION ⏺️", 
            stop_prompt="STOP ⏹️", 
            format="wav",
            use_container_width=True,
            key='recorder'
        )

    if recording:  
        user_question = asr_transcription(recording['bytes'], oai_client)

        if prompt := user_question:
            st.session_state.messages.append({"role": "user", "content": prompt, "avatar":"👤"})
            messages.chat_message("user", avatar="👤").write(prompt)
            msg = llm_answer(st.session_state.messages, oai_client)
            st.session_state.messages.append({"role": "assistant", "content": msg, "avatar": "🤖"})
            messages.chat_message("system", avatar="🤖").write(msg)

            if msg is not None:
                audio_samples, sample_rate_hz = tts_synthesis(msg, tts_client)
                placeholder.audio(audio_samples, sample_rate=sample_rate_hz, autoplay=True)

Lancer l'application web Streamlit en local

🚀 Voilà ! Votre application web est maintenant prête à être utilisée ! Vous pouvez démarrer cette application Streamlit en local en lançant la commande suivante :

streamlit run audio-virtual-assistant-app.py

app-overview

Améliorations

Par défaut, le modèle nvr-tts-en-us ne prend en charge qu'un nombre limité de caractères par requête lors de la génération audio. Si vous dépassez cette limite, vous rencontrerez des erreurs dans votre application.

Pour contourner cette limitation, vous pouvez remplacer la fonction tts_synthesis existante par l'implémentation suivante, qui traite le texte par blocs :

def tts_synthesis(response, tts_client):
    # Split response into chunks of max 1000 characters
    max_chunk_length = 1000
    words = response.split()
    chunks = []
    current_chunk = ""

    for word in words:
        if len(current_chunk) + len(word) + 1 <= max_chunk_length:
            current_chunk += " " + word if current_chunk else word
        else:
            chunks.append(current_chunk)
            current_chunk = word
    if current_chunk:
        chunks.append(current_chunk)

    all_audio = np.array([], dtype=np.int16)
    sample_rate_hz = 16000

    # Process each chunk and concatenate the resulting audio
    for text in chunks:
        req = {
            "language_code": "en-US",
            "encoding": riva.client.AudioEncoding.LINEAR_PCM,
            "sample_rate_hz": sample_rate_hz,
            "voice_name": "English-US.Female-1",
            "text": text.strip(),
        }
        synthesized = tts_client.synthesize(**req)
        audio_segment = np.frombuffer(synthesized.audio, dtype=np.int16)
        all_audio = np.concatenate((all_audio, audio_segment))

    return all_audio, sample_rate_hz

Conclusion

Vous venez de créer un assistant vocal virtuel (Audio Virtual Assistant) capable de mener une conversation naturelle à la voix, propulsé par les endpoints d'ASR, de LLM et de TTS.

Cet exemple démontre à quel point il est puissant, tout en restant simple, de tirer parti des services d'IA d'OVHcloud pour construire des applications intelligentes en quelques lignes de code.

➡️ Accédez au code complet ici.

Aller plus loin

Si vous souhaitez aller plus loin et déployer votre application web dans le cloud, en rendant votre interface accessible à tous, reportez-vous aux articles et tutoriels suivants :

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page Professional Services pour obtenir un devis et faire analyser votre projet par nos experts.

Votre avis nous intéresse !

N’hésitez pas à nous faire part de vos questions, retours et suggestions concernant AI Endpoints et ses fonctionnalités :

  • Dans le canal #ai-endpoints du serveur Discord OVHcloud, où vous pouvez échanger avec la communauté et les équipes OVHcloud.
Cette page vous a-t-elle aidé ?