Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Multimodal stemmeassistent

Lektion 16 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. Multimodal stemmeassistent
  2. Tekst og lyd parallelt
  3. Visning af et billede for stemmeagenten
  4. Multimodal webgrænseflade
  5. Multimodale brugsscenarier
  6. Vigtige pointer

Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts ophører med at fungere den 6. januar 2027 (den angivne erstatning er gpt-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-realtime og ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations den 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. Men gpt-realtime-2.1 og gpt-realtime-2 accepterer billeder som input: billedet vedhæftes direkte, som input_image, til en brugerbesked. Hændelsen response.text.delta fra den gamle beta-version hedder nu response.output_text.delta. Hændelsesstrukturer er verificeret mod openai SDK-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.create giver dig mulighed for at berige talekonteksten
  • Realtime-modeller accepterer billeder: vedhæft dem som input_image til 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