Assistent vocal multimodal
Sellel lehel
Mis à jour le 2 novembre 2026 — Modèles audio. Plusieurs modèles de ce cours sont obsolètes :
tts-1,tts-1-hdetgpt-4o-mini-ttscesseront de fonctionner le 6 janvier 2027 (le remplacement indiqué estgpt-realtime-2.1-mini, que le guide TTS d’OpenAI précise ne pas être pris en charge par/v1/audio/speech: la migration de la synthèse vocale doit passer par l’API Realtime) ;gpt-realtime,gpt-4o-realtimeet les anciens modèles audio le 20 janvier 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5) ;whisper-1,gpt-4o-transcribeet/v1/audio/translationsle 26 février 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pour la voix en full-duplex, GPT-Live 1 est disponible dans l’API depuis le 10 septembre 2026.
Corrigé le 3 novembre 2026. Pour analyser une image, la leçon précédente effectuait un appel séparé à l’API Responses, puis injectait la description comme un message d’assistant avec un contenu
input_text, un type réservé aux messages utilisateur ou système. Cependant,gpt-realtime-2.1etgpt-realtime-2acceptent les images en entrée : l’image est jointe directement, sous formeinput_image, à un message utilisateur. L’événementresponse.text.deltade l’ancienne bêta est désormais nomméresponse.output_text.delta. Formes d’événements vérifiées contre les types SDKopenai3.42.1. Sources : Conversations en temps réel, Entrées d’images · gpt-realtime-2.1.
Assistent vocal multimodal
Un assistant vocal multimodal combine la voix avec d’autres modalités : texte, images, vidéo et données structurées. L’utilisateur parle, mais l’agent peut aussi afficher des informations visuelles, analyser des images envoyées par l’utilisateur ou combiner plusieurs sources de données. C’est l’avenir de l’interaction homme-machine.
Texte et audio en parallèle
L’API Realtime prend nativement en charge les modalités texte et audio simultanément. Tu peux injecter du texte dans la conversation tout en maintenant l’échange vocal :
async def inject_text_context(ws, context: str):
"""Ajoute un contexte textuel à la conversation vocale."""
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": context
}
]
}
}))
# Déclenche une réponse vocale basée sur ce contexte
await ws.send(json.dumps({"type": "response.create"}))
# L'utilisateur demande oralement « Lis-moi mon dernier e-mail »
# Tu injectes le contenu de l'e-mail sous forme de texte
await inject_text_context(ws, """
Voici le dernier e-mail reçu :
De : [email protected]
Objet : Demande de devis
Contenu : Bonjour, je souhaiterais obtenir un devis pour
l'intégration d'un agent vocal dans notre centre d'appels.
""")
Montrer une image à l’agent vocal
gpt-realtime-2.1 et gpt-realtime-2 acceptent le texte, l’audio et les images en entrée. Une image est jointe comme partie input_image d’un message utilisateur, via un URI de données Base64, à la fois sur WebSocket et sur le canal de données WebRTC. Le modèle en tient compte dans sa réponse vocale, sans appeler une autre API :
import base64
import json
async def montrer_image(ws, chemin_image: str, question: str) -> None:
"""Joint une image et une question à la conversation, puis demande une réponse vocale."""
with open(chemin_image, "rb") as f:
image_b64 = base64.b64encode(f.read()).decode()
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [
{"type": "input_image", "image_url": f"data:image/jpeg;base64,{image_b64}"},
{"type": "input_text", "text": question},
],
},
}))
await ws.send(json.dumps({"type": "response.create"}))
await montrer_image(ws, "facture.jpg", "Que dois-je payer et pour quelle date ?")
Les images sont facturées comme des jetons d’image, à un tarif spécifique indiqué sur la fiche du modèle. Pour une analyse lourde ou pour utiliser un modèle de vision plus performant, tu peux toujours interroger l’API Responses séparément, puis transmettre son résultat à la session : fais-le via un message system ou user (avec un contenu input_text), jamais via un faux message d’assistant, que le modèle interpréterait comme ses propres paroles.
Interface web multimodale
Pour une application web, combine le WebSocket Realtime avec une interface visuelle :
from fastapi import FastAPI, WebSocket
from fastapi.staticfiles import StaticFiles
app = FastAPI()
@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
"""Agent multimodal avec interface web."""
await client_ws.accept()
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(REALTIME_URL, additional_headers=headers) as openai_ws:
await openai_ws.recv() # session.created
await openai_ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "Assistant multimodal. Réponds en français.",
"audio": {"output": {"voice": "marin"}}
}
}))
await openai_ws.recv()
async def client_to_openai():
async for message in client_ws.iter_text():
data = json.loads(message)
if data["type"] == "audio":
# Relais audio
await openai_ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": data["audio"]
}))
elif data["type"] == "text":
# Message texte (chat)
await openai_ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [{
"type": "input_text",
"text": data["text"]
}]
}
}))
await openai_ws.send(json.dumps({
"type": "response.create"
}))
async def openai_to_client():
async for message in openai_ws:
event = json.loads(message)
t = event["type"]
if t == "response.output_audio.delta":
await client_ws.send_json({
"type": "audio",
"delta": event["delta"]
})
elif t == "response.output_audio_transcript.delta":
await client_ws.send_json({
"type": "transcript",
"delta": event["delta"]
})
elif t == "response.output_text.delta":
await client_ws.send_json({
"type": "text",
"delta": event["delta"]
})
await asyncio.gather(client_to_openai(), openai_to_client())
Cas d’usage multimodaux
Voici comment un agent multimodal gère différents scénarios dans un outil d’appel de fonction :
tools = [
{
"type": "function",
"name": "show_chart",
"description": "Affiche un graphique de données à l'utilisateur",
"parameters": {
"type": "object",
"properties": {
"chart_type": {"type": "string", "enum": ["bar", "line", "pie"]},
"title": {"type": "string"},
"data": {"type": "object"}
},
"required": ["chart_type", "title", "data"]
}
},
{
"type": "function",
"name": "send_document",
"description": "Envoie un document au client par e-mail",
"parameters": {
"type": "object",
"properties": {
"document_type": {"type": "string"},
"recipient": {"type": "string"}
},
"required": ["document_type", "recipient"]
}
}
]
L’utilisateur dit oralement : « Montre-moi les ventes du dernier trimestre sous forme de graphique. » L’agent appelle show_chart, ton frontend affiche le graphique, et l’agent commente oralement les résultats.
Peamised punktid
- L’API Realtime prend en charge simultanément les modalités texte et audio dans la même session
- L’injection de texte via
conversation.item.createpermet d’enrichir le contexte vocal - Les modèles Realtime acceptent les images : joins-les sous forme
input_imageà un message utilisateur - Les outils (appel de fonction) te permettent d’afficher des éléments visuels tout en répondant oralement
- L’architecture WebSocket côté client permet de mixer audio, texte et données structurées