Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Assistent vocal multimodal

Les 16 van 18 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Assistant vocal multimodal
  2. Texte et audio en parallèle
  3. Montrer une image à l’agent vocal
  4. Interface web multimodale
  5. Cas d’usage multimodaux
  6. Belangrijkste punten

Mis à jour le 2 novembre 2026 — Modèles audio. Plusieurs modèles de ce cours sont obsolètes : tts-1, tts-1-hd et gpt-4o-mini-tts cesseront de fonctionner le 6 janvier 2027 (le remplacement indiqué est gpt-realtime-2.1-mini, que le guide TTS d’OpenAI précise comme non pris en charge par /v1/audio/speech : la migration de la synthèse vocale doit passer par l’API Realtime) ; gpt-realtime, gpt-4o-realtime et 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-transcribe et /v1/audio/translations le 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 effectuait auparavant un appel séparé à l’API Responses, puis injectait la description sous forme de message d’assistant avec un contenu input_text, un type réservé aux messages utilisateur ou système. Cependant, gpt-realtime-2.1 et gpt-realtime-2 acceptent les images en entrée : l’image est jointe directement, en tant que input_image, à un message utilisateur. L’événement response.text.delta de l’ancienne bêta est désormais nommé response.output_text.delta. Formes d’événements vérifiées par rapport aux types SDK openai 3.42.1. Sources : Conversations en temps réel, entrées d’images · gpt-realtime-2.1.

Assistant 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 également 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. Vous pouvez 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 verbalement "Lis-moi mon dernier e-mail"
# Vous injectez 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 en tant que 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 en tant que jetons d’image, selon un tarif spécifique indiqué sur la fiche du modèle. Pour une analyse approfondie ou pour utiliser un modèle de vision plus performant, vous pouvez toujours interroger l’API Responses séparément, puis transmettre son résultat à la session : faites-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, combinez 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épondez en anglais.",
                "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 verbalement : « Montrez-moi les ventes du dernier trimestre sous forme de graphique. » L’agent appelle show_chart, votre frontend affiche le graphique, et l’agent commente verbalement les résultats.

Belangrijkste punten

  • 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.create permet d’enrichir le contexte vocal
  • Les modèles Realtime acceptent les images : joignez-les en tant que input_image à un message utilisateur
  • Les outils (appel de fonction) vous permettent d’afficher des éléments visuels tout en répondant verbalement
  • L’architecture WebSocket côté client vous permet de mixer audio, texte et données structurées