Création d'un agent vocal multilingue à l'aide de l'OpenAI Kit de développement logiciel (SDK) de l'agent

Les applications vocales sont passées des concepts de science-fiction aux solutions déployables avec OpenAI's outils les plus récents. Ce guide présente la mise en œuvre pratique de agents vocaux multilingues utilisant OpenAI Kit de développement logiciel (SDK) de l'agent, démontrant comment créer des systèmes qui traitent la parole dans différentes langues tout en maintenant des rythmes d'interaction de type humain.

Qu'est-ce qui est ouvertAI SDK d'agent ?

OuvrezAI Agent SDK fournit aux développeurs un cadre pour créer AI Agents capables de traiter et de répondre à diverses entrées, y compris vocales. Le SDK prend en charge le modèle GPT-4o-realtime-preview, qui permet capacités de conversation en temps réel grâce à son avancée Traitement du langage naturel (PNL) fonctionnalités.

Le SDK inclut notamment VoicePipeline, un composant conçu pour gérer les interactions vocales de manière fluide. Ce pipeline gère le processus complexe de conversion de la parole en texte, de traitement des informations et de génération de réponses naturelles.

Architecture de base des agents vocaux modernes

1. Le pipeline de traitement de la parole

OpenAI's VoicePipeline fonctionne en trois étapes synchronisées : la capture audio, le traitement du langage et la génération de la réponse. Le système commence par convertir les signaux audio bruts en texte à l'aide de parole-texte Des modèles comme GPT-4o Transcribe. Ces données textuelles alimentent ensuite des modèles linguistiques qui analysent le contexte, l'intention et le ton émotionnel. Enfin, les composants de synthèse vocale génèrent des réponses vocales naturelles tout en préservant le flux de la conversation.

2. Architectures multimodales vs architectures en chaîne

Deux approches distinctes dominent le développement des agents vocaux :

Guide de l'agent vocal multilingue : du code à la conversation

Créer des agents vocaux avec OpenAI Le SDK Agent nécessite des configurations d'environnement spécifiques. Suivez ces étapes pour créer un environnement de développement fonctionnel avec des fonctionnalités vocales.

Étape 1. Configuration de Python et de l'environnement virtuel

Assurez-vous que Python 3.8 ou version ultérieure est installé. Vérifiez avec :

python --version  

Pour les nouvelles installations, téléchargez Python depuis python.org.

a. Créer un environnement virtuel

Isoler les dépendances pour éviter les conflits :

p-ython -m venv voice_agent_env  

b. Activation:

• Linux/macOS:

source voice_agent_env/bin/activate  

• Windows:

voice_agent_env\Scripts\activate  

c. Installer les dépendances spécifiques à la voix

Installer l'OpenAI Agents SDK avec extensions vocales et bibliothèques audio :

pip install 'openai-agents[voice]' numpy sounddevice scipy python-dotenv  

d. Configurer OuvrirAI clé API: Stockez votre clé API en toute sécurité à l'aide de variables d'environnement :

1. Créer un .env fichier:

echo "OPENAI_API_KEY=your-api-key-here" > .env  

2. Cloner le référentiel d'exemples (facultatif) :

Pour accélérer les choses, vous pouvez cloner l'exemple officiel à partir du OuvrezAI Dépôt GitHub du SDK Agents.

git clone https://github.com/openai/openai-agents-python.git
cd openai-agents-python/examples/voice/static

Étape 2. Création de l'agent multilingue

Les principaux composants comprennent :

• Agents spécifiques à la langue pour différentes langues (espagnol, hindi)
• Un agent principal qui gère les interactions initiales
• Outils fonctionnels pour des fonctionnalités supplémentaires (comme les informations météorologiques)

Ici's une version simplifiée de la structure du code :

a. Définissez vos agents

Créez des instances d'agent distinctes pour chaque langue prise en charge. Par exemple, vous pouvez créer un agent espagnol et un agent hindi avec des instructions dans leur langue respective :

from agents import Agent
from agents.extensions.handoff_prompt import prompt_with_handoff_instructions

spanish_agent = Agent(
    name="Spanish",
    handoff_description="A Spanish speaking agent.",
    instructions=prompt_with_handoff_instructions(
        "You're speaking to a human, so be polite and concise. Speak in Spanish."
    ),
    model="gpt-4o-mini",
)

hindi_agent = Agent(
    name="Hindi",
    handoff_description="A Hindi speaking agent.",
    instructions=prompt_with_handoff_instructions(
        "You're speaking to a human, so be polite and concise. Speak in Hindi."
    ),
    model="gpt-4o-mini",
)

Créez votre assistant principal qui détectera la langue à partir du discours de l'utilisateur et déléguera à l'agent approprié si nécessaire :

agent = Agent(
    name="Assistant",
    instructions=prompt_with_handoff_instructions(
        "You're speaking to a human, so be polite and concise. If the user speaks in Spanish, hand off to the Spanish agent. If the user speaks in Hindi, hand off to the Hindi agent."
    ),
    model="gpt-4o-mini",
    handoffs=[spanish_agent, hindi_agent],
)

b. Ajouter des outils (facultatif)

Par exemple, vous pouvez ajouter un outil météo simple que l'agent pourrait appeler :

import random
from agents import function_tool

@function_tool
def get_weather(city: str) -> str:
    choices = ["sunny", "cloudy", "rainy", "snowy"]
    return f"The weather in {city} is {random.choice(choices)}."
    
agent.tools.append(get_weather)

Étape 3. Configuration du pipeline vocal

Le pipeline vocal du SDK combine trois composants :

1. Conversion de la parole en texte (STT) : Convertit votre entrée audio en texte.
2. Workflow Agentic : Traite le texte (y compris la détection de la langue et l'invocation de l'outil).
3. Synthèse vocale (TTS) : Convertit l'agent's réponse textuelle en audio.

Ici's un exemple simplifié :

import asyncio
import numpy as np
import sounddevice as sd
from agents.voice import AudioInput, SingleAgentVoiceWorkflow, VoicePipeline

async def main():
    # Create the voice pipeline with your primary agent
    pipeline = VoicePipeline(workflow=SingleAgentVoiceWorkflow(agent))
    
    # For demonstration, we'll simulate 3 seconds of audio input with silence.
    buffer = np.zeros(24000 * 3, dtype=np.int16)
    audio_input = AudioInput(buffer=buffer)
    
    # Run the pipeline
    result = await pipeline.run(audio_input)
    
    # Set up the audio player (using sounddevice)
    player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
    player.start()
    
    # Stream and play audio events from the agent's output
    async for event in result.stream():
        if event.type == "voice_stream_event_audio":
            player.write(event.data)

if __name__ == "__main__":
    asyncio.run(main())

Dans une application réelle, au lieu du silence, vous captureriez l'entrée du microphone en direct et l'agent détecterait la langue en temps réel.

Étape 4 : Exécutez votre agent vocal

python -m examples.voice.static.main

Prenez les devants avec votre agent vocal multilingue dès aujourd'hui

Créer des agents vocaux avec l'OpenAI Le SDK Agent est devenu nettement plus accessible. Les développeurs peuvent désormais choisir entre des architectures multimodales ou en chaîne selon leurs besoins spécifiques, configurer un VoicePipeline et laisser le SDK gérer le processus. traitement complexe.

Pour la qualité du flux conversationnel, l'approche multimodale est la plus efficace. Pour la structure et le contrôle, la méthode enchaînée est plus adaptée. Cette technologie continue de progresser, ouvrant de nouvelles possibilités pour les applications vocales.