Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Többmódusú hangasszisztens

16. lecke 18 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Többmódusú hangasszisztens
  2. Szöveg és hang párhuzamosan
  3. Kép megjelenítése a hangügynök számára
  4. Többmódusú webes felület
  5. Többmódusú használati esetek
  6. Főbb megállapítások

Frissítve: 2026. november 2. – Hangmodellek. A tanfolyam több modellje elavult: a tts-1, tts-1-hd és a gpt-4o-mini-tts 2027. január 6-án megszűnik működni (a javasolt helyettesítőjük a gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint a /v1/audio/speech nem támogat: a szöveg-beszéd migrációt a Realtime API-n keresztül kell végrehajtani); a gpt-realtime, gpt-4o-realtime és a régi hangmodellek 2027. január 20-án válnak elavulttá (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); a whisper-1, gpt-4o-transcribe és a /v1/audio/translations pedig 2027. február 26-án (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). A teljes duplex hangkommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.

Helyesbítve: 2026. november 3. Egy kép elemzéséhez a lecke korábban külön hívást intézett a Responses API-hoz, majd a leírást asszisztens üzenetként illesztette be input_text tartalommal, ami a felhasználói vagy rendszerüzeneteknek fenntartott típus. A gpt-realtime-2.1 és a gpt-realtime-2 azonban közvetlenül fogad képeket bemenetként: a képet közvetlenül csatolhatod input_imageként egy felhasználói üzenethez. A régi béta verzióból ismert response.text.delta esemény neve most response.output_text.delta. Az eseménystruktúrákat az openai SDK 3.42.1-es típusai alapján ellenőriztük. Források: Valós idejű beszélgetések, Képbemenetek · gpt-realtime-2.1.

Többmódusú hangasszisztens

A többmódusú hangasszisztens egyesíti a hangot más módusokkal: szöveggel, képekkel, videóval és strukturált adatokkal. A felhasználó beszél, de az ügynök képes vizuális információk megjelenítésére, a felhasználó által küldött képek elemzésére, vagy több adatforrás kombinálására is. Ez az ember-számítógép interakció jövője.

Szöveg és hang párhuzamosan

A Realtime API natívan támogatja a szöveg és a hang módusainak egyidejű használatát. Szöveget injektálhatsz a beszélgetésbe anélkül, hogy megszakítanád a hangalapú kommunikációt:

async def inject_text_context(ws, context: str):
    """Szöveges kontextust ad hozzá a hangalapú beszélgetéshez."""
    await ws.send(json.dumps({
        "type": "conversation.item.create",
        "item": {
            "type": "message",
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": context
                }
            ]
        }
    }))

    # Hangalapú válasz kiváltása ezen kontextus alapján
    await ws.send(json.dumps({"type": "response.create"}))

# A felhasználó szóban azt kéri: "Olvasd fel a legújabb e-mailemet"
# Te beszúrod az e-mail tartalmát szövegként
await inject_text_context(ws, """
Íme a legutóbb érkezett e-mail:
Feladó: [email protected]
Tárgy: Árajánlatkérés
Tartalom: Üdvözölöm, árajánlatot szeretnék kérni
egy hangügynök integrálására a call centerünkbe.
""")

Kép megjelenítése a hangügynök számára

A gpt-realtime-2.1 és a gpt-realtime-2 modellek szöveget, hangot és képeket is elfogadnak bemenetként. A képet egy felhasználói üzenet input_image részeként csatolod, Base64 kódolású Data URI formátumban, mind WebSocket, mind WebRTC adatcsatorna esetén. A modell figyelembe veszi ezt a hangalapú válaszában, további API-hívás nélkül:

import base64
import json


async def montrer_image(ws, chemin_image: str, question: str) -> None:
    """Képet és kérdést csatol a beszélgetéshez, majd hangalapú választ kér."""
    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", "Mit kell fizetnem, és meddig?")

A képek után számlázás képtokenek alapján történik, a modellkártyán feltüntetett specifikus díjszabás szerint. Komolyabb elemzéshez vagy fejlettebb látómodellhez továbbra is lekérdezheted külön a Responses API-t, majd az eredményt továbbíthatod a munkamenetbe: ezt system vagy user üzenettel tedd (input_text tartalommal), soha ne hamis asszisztens üzenettel, mert azt a modell a saját szavainak értelmezné.

Többmódusú webes felület

Webes alkalmazáshoz kombináld a Realtime WebSocketet egy vizuális felülettel:

from fastapi import FastAPI, WebSocket
from fastapi.staticfiles import StaticFiles

app = FastAPI()

@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
    """Többmódusú ügynök webes felülettel."""
    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": "Többmódusú asszisztens. Válaszolj angolul.",
                "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":
                    # Hang továbbítása
                    await openai_ws.send(json.dumps({
                        "type": "input_audio_buffer.append",
                        "audio": data["audio"]
                    }))

                elif data["type"] == "text":
                    # Szöveges üzenet (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())

Többmódusú használati esetek

Így kezel egy többmódusú ügynök különböző forgatókönyveket egy function calling eszközön keresztül:

tools = [
    {
        "type": "function",
        "name": "show_chart",
        "description": "Adatdiagramot jelenít meg a felhasználónak",
        "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": "Dokumentumot küld az ügyfélnek e-mailben",
        "parameters": {
            "type": "object",
            "properties": {
                "document_type": {"type": "string"},
                "recipient": {"type": "string"}
            },
            "required": ["document_type", "recipient"]
        }
    }
]

A felhasználó szóban azt mondja: „Mutasd meg az elmúlt negyedév eladásait diagramon.“ Az ügynök meghívja a show_chart függvényt, a frontended megjeleníti a diagramot, az ügynök pedig szóban kommentálja az eredményeket.

Főbb megállapítások

  • A Realtime API egyszerre támogatja a szöveg és a hang módusait ugyanabban a munkamenetben
  • A szöveg beszúrása a conversation.item.create segítségével gazdagítja a hangkontextust
  • A Realtime modellek elfogadnak képeket: csatold őket input_imageként egy felhasználói üzenethez
  • Az eszközök (function calling) lehetővé teszik vizuális elemek megjelenítését a szóbeli válaszadás mellett
  • A kliensoldali WebSocket architektúra lehetővé teszi a hang, a szöveg és a strukturált adatok keverését