Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Asistent glasovne komunikacije s više modaliteta

Lekcija 16 od 18 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Asistent glasovne komunikacije s više modaliteta
  2. Tekst i zvuk paralelno
  3. Prikazivanje slike glasovnom agentu
  4. Višemodalno web sučelje
  5. Upotreba višemodalnih agenata
  6. Ključne točke

Ažurirano 2. studenoga 2026. — Modeli za zvuk. Nekoliko modela u ovom tečaju je zastarjelo: tts-1, tts-1-hd i gpt-4o-mini-tts prestat će raditi 6. siječnja 2027. (navedena zamjena je gpt-realtime-2.1-mini, za koju OpenAI vodič za TTS navodi da nije podržana putem /v1/audio/speech: migracija sinteze govora mora se obaviti kroz Realtime API); gpt-realtime, gpt-4o-realtime i stariji zvučni modeli 20. siječnja 2027. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe i /v1/audio/translations 26. veljače 2027. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za full-duplex glasovnu komunikaciju, GPT-Live 1 dostupan je u API-ju od 10. rujna 2026.

Ispravljeno 3. studenoga 2026. Za analizu slike, lekcija je prethodno koristila zaseban poziv Responses API-ju, a zatim ubacivala opis kao poruku asistenta sa sadržajem input_text, što je tip rezerviran za poruke korisnika ili sustava. Međutim, gpt-realtime-2.1 i gpt-realtime-2 prihvaćaju slike kao ulaz: slika se izravno prilaže, kao input_image, uz poruku korisnika. Događaj response.text.delta iz stare beta verzije sada se naziva response.output_text.delta. Oblici događaja verificirani su prema tipovima SDK-a openai verzije 3.42.1. Izvori: Realtime conversations, Image inputs · gpt-realtime-2.1.

Asistent glasovne komunikacije s više modaliteta

Asistent glasovne komunikacije s više modaliteta kombinira glas s drugim modalitetima: tekstom, slikama, videom i strukturiranim podacima. Korisnik govori, ali agent može prikazivati i vizualne informacije, analizirati slike koje pošalje korisnik ili kombinirati više izvora podataka. To je budućnost interakcije između čovjeka i računala.

Tekst i zvuk paralelno

Realtime API izvorno podržava tekstualne i zvučne modalitete istovremeno. Možeš ubaciti tekst u razgovor dok istovremeno održavaš glasovnu razmjenu:

async def inject_text_context(ws, context: str):
    """Adds text context to the voice conversation."""
    await ws.send(json.dumps({
        "type": "conversation.item.create",
        "item": {
            "type": "message",
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": context
                }
            ]
        }
    }))

    # Trigger a voice response based on this context
    await ws.send(json.dumps({"type": "response.create"}))

# The user verbally asks "Read me my latest email"
# You inject the email content as text
await inject_text_context(ws, """
Here is the latest email received:
From: [email protected]
Subject: Quote Request
Content: Hello, I would like to request a quote for
integrating a voice agent into our call center.
""")

Prikazivanje slike glasovnom agentu

gpt-realtime-2.1 i gpt-realtime-2 prihvaćaju tekst, zvuk i slike kao ulaz. Slika se prilaže kao dio input_image poruke korisnika, koristeći Base64 Data URI, kako preko WebSocket-a tako i preko WebRTC podatkovnog kanala. Model to uzima u obzir u svom glasovnom odgovoru, bez potrebe za pozivanjem drugog API-ja:

import base64
import json


async def montrer_image(ws, chemin_image: str, question: str) -> None:
    """Attaches an image and a question to the conversation, then requests a voice response."""
    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", "What do I need to pay, and by what date?")

Slike se naplaćuju kao tokeni za slike, po specifičnoj stopi navedenoj na kartici modela. Za opsežnu analizu ili korištenje sposobnijeg modela za viziju, i dalje možeš zasebno upitati Responses API, a zatim proslijediti njegov rezultat sesiji: učini to putem poruke system ili user (sa sadržajem input_text), nikada putem lažne poruke asistenta, koju bi model protumačio kao vlastite riječi.

Višemodalno web sučelje

Za web aplikaciju kombiniraj Realtime WebSocket s vizualnim sučeljem:

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 with web interface."""
    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":
                    # Relay audio
                    await openai_ws.send(json.dumps({
                        "type": "input_audio_buffer.append",
                        "audio": data["audio"]
                    }))

                elif data["type"] == "text":
                    # Text message (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())

Upotreba višemodalnih agenata

Evo kako višemodalni agent obrađuje različite scenarije u alatu za pozivanje funkcija:

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"]
        }
    }
]

Korisnik glasovno kaže: „Prikaži mi prodaju iz prošlog kvartala kao graf.“ Agent poziva show_chart, tvoj frontend prikazuje graf, a agent usmeno komentira rezultate.

Ključne točke

  • Realtime API podržava tekstualne i zvučne modalitete istovremeno u istoj sesiji
  • Umetanje teksta putem conversation.item.create omogućuje obogaćivanje glasovnog konteksta
  • Realtime modeli prihvaćaju slike: priloži ih kao input_image uz poruku korisnika
  • Alati (pozivanje funkcija) omogućuju prikaz vizualnih elemenata dok se odgovara glasovno
  • Arhitektura WebSocket-a na strani klijenta omogućuje miješanje zvuka, teksta i strukturiranih podataka