Multimodal stemmeassistent
På denne side
Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset:
tts-1,tts-1-hdoggpt-4o-mini-ttsophører med at fungere den 6. januar 2027 (den angivne erstatning ergpt-realtime-2.1-mini, som OpenAI’s TTS-guide angiver ikke understøttes af/v1/audio/speech: migration af talesyntese skal ske via Realtime API);gpt-realtime,gpt-4o-realtimeog ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeog/v1/audio/translationsden 26. februar 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.
Rettet 3. november 2026. For at analysere et billede lavede lektionen tidligere et separat kald til Responses API og injicerede derefter beskrivelsen som en assistent-besked med
input_text-indhold, en type reserveret til bruger- eller systembeskeder. Mengpt-realtime-2.1oggpt-realtime-2accepterer billeder som input: billedet vedhæftes direkte, sominput_image, til en brugerbesked. Hændelsenresponse.text.deltafra den gamle beta-version hedder nuresponse.output_text.delta. Hændelsesstrukturer er verificeret modopenaiSDK-typer 3.42.1. Kilder: Realtime conversations, Image inputs · gpt-realtime-2.1.
Multimodal stemmeassistent
En multimodal stemmeassistent kombinerer tale med andre modaliteter: tekst, billeder, video og strukturerede data. Brugeren taler, men agenten kan også vise visuel information, analysere billeder sendt af brugeren eller kombinere flere datakilder. Dette er fremtiden for menneske-maskine-interaktion.
Tekst og lyd parallelt
Realtime API understøtter naturligt tekst- og lydmodaliteter samtidigt. Du kan injicere tekst i samtalen, mens taleudvekslingen fortsætter:
async def inject_text_context(ws, context: str):
"""Tilføjer tekstkontekst til talesamtalen."""
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": context
}
]
}
}))
# Udløs et talesvar baseret på denne kontekst
await ws.send(json.dumps({"type": "response.create"}))
# Brugeren spørger verbalt "Læs min seneste e-mail op"
# Du injicerer e-mail-indholdet som tekst
await inject_text_context(ws, """
Her er den seneste modtagne e-mail:
Fra: [email protected]
Emne: Tilbudsforespørgsel
Indhold: Hej, jeg vil gerne anmode om et tilbud på
integration af en stemmeagent i vores callcenter.
""")
Visning af et billede for stemmeagenten
gpt-realtime-2.1 og gpt-realtime-2 accepterer tekst, lyd og billeder som input. Et billede vedhæftes som en input_image-del af en brugerbesked ved hjælp af en Base64 Data URI, både over WebSocket og WebRTC-datakanalen. Modellen tager højde for dette i sit talesvar uden at kalde en anden API:
import base64
import json
async def montrer_image(ws, chemin_image: str, question: str) -> None:
"""Vedhæfter et billede og et spørgsmål til samtalen og anmoder derefter om et talesvar."""
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", "Hvad skal jeg betale, og inden hvilken dato?")
Billeder faktureres som billedtokens til en specifik sats, der er angivet på modelkortet. Til tung analyse eller en mere capable visionsmodel kan du stadig spørge Responses API separat og derefter sende resultatet til sessionen: gør dette via en system- eller user-besked (med input_text-indhold), aldrig via en falsk assistent-besked, som modellen ville fortolke som sine egne ord.
Multimodal webgrænseflade
Til en webapplikation kombinerer du Realtime WebSocket med en visuel grænseflade:
from fastapi import FastAPI, WebSocket
from fastapi.staticfiles import StaticFiles
app = FastAPI()
@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
"""Multimodal agent med webgrænseflade."""
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": "Multimodal assistant. Respond in English.",
"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":
# Videresend lyd
await openai_ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": data["audio"]
}))
elif data["type"] == "text":
# Tekstbesked (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())
Multimodale brugsscenarier
Sådan håndterer en multimodal agent forskellige scenarier i et funktionkalds-værktøj:
tools = [
{
"type": "function",
"name": "show_chart",
"description": "Displays a data chart to the user",
"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": "Sends a document to the client by email",
"parameters": {
"type": "object",
"properties": {
"document_type": {"type": "string"},
"recipient": {"type": "string"}
},
"required": ["document_type", "recipient"]
}
}
]
Brugeren siger verbalt: „Vis mig salgstallene for sidste kvartal som et diagram.” Agenten kalder show_chart, din frontend viser diagrammet, og agenten kommenterer resultaterne verbalt.
Vigtige pointer
- Realtime API understøtter tekst- og lydmodaliteter samtidigt i samme session
- Injektion af tekst via
conversation.item.creategiver dig mulighed for at berige talekonteksten - Realtime-modeller accepterer billeder: vedhæft dem som
input_imagetil en brugerbesked - Værktøjer (funktionkald) giver dig mulighed for at vise visuelle elementer, mens du svarer verbalt
- Klient-side WebSocket-arkitektur giver dig mulighed for at blande lyd, tekst og strukturerede data