Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Assistent vocal multimodal

Õppetund 16 / 18 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Assistent 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. Peamised punktid

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 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-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 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.1 et gpt-realtime-2 acceptent les images en entrée : l’image est jointe directement, sous forme 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 contre les types SDK openai 3.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.create permet 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