Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Avustaja multimodaalisella äänellä

Oppitunti 16 / 18 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Avustaja multimodaalisella äänellä
  2. Teksti ja ääni rinnakkain
  3. Kuvan näyttäminen ääniavustajalle
  4. Multimodaalinen verkkoliittymä
  5. Multimodaalisia käyttötapauksia
  6. Keskeiset asiat

Päivitetty 2. marraskuuta 2026 — Äänimallit. Useat tämän kurssin malleista on poistettu käytöstä: tts-1, tts-1-hd ja gpt-4o-mini-tts lakkaavat toimimasta 6. tammikuuta 2027 (suositeltu korvaaja on gpt-realtime-2.1-mini, jonka OpenAI:n TTS-opas ilmoittaa ei tukevan polkua /v1/audio/speech: puheentuotannon siirtymän on kuljettava Realtime API:n kautta); gpt-realtime, gpt-4o-realtime ja vanhat äänimallit 20. tammikuuta 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ja /v1/audio/translations 26. helmikuuta 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Täysdupleksista ääntä varten GPT-Live 1 on ollut saatavilla API:ssa 10. syyskuuta 2026 lähtien.

Korjattu 3. marraskuuta 2026. Kuvan analysoimiseksi oppitunti teki aiemmin erillisen pyynnön Responses API:lle ja syötti kuvauksen avustajan viestinä, jossa oli input_text-sisältöä – tämä tyyppi on varattu käyttäjän tai järjestelmän viesteille. Mallit gpt-realtime-2.1 ja gpt-realtime-2 kuitenkin hyväksyvät kuvat syötteenä: kuva liitetään suoraan käyttäjän viestiin muodossa input_image. Vanhan beta-version response.text.delta-tapahtuma on nyt nimetty response.output_text.delta:ksi. Tapahtumien rakenteet on varmistettu openai-SDK:n tyyppien 3.42.1 mukaisesti. Lähteet: Realtime conversations, Image inputs · gpt-realtime-2.1.

Avustaja multimodaalisella äänellä

Multimodaalinen ääniavustaja yhdistää puheen muihin modaliteetteihin: tekstiin, kuviin, videoon ja jäsenneltyyn dataan. Käyttäjä puhuu, mutta avustaja voi myös näyttää visuaalista tietoa, analysoida käyttäjän lähettämiä kuvia tai yhdistää useita datalähteitä. Tämä on ihmisen ja tietokoneen vuorovaikutuksen tulevaisuus.

Teksti ja ääni rinnakkain

Realtime API tukee natiivisti teksti- ja äänimodaliteetteja samanaikaisesti. Voit syöttää tekstiä keskusteluun pitäen samalla yllä ääniviestintää:

async def inject_text_context(ws, context: str):
    """Lisää tekstikontekstin äänikeskusteluun."""
    await ws.send(json.dumps({
        "type": "conversation.item.create",
        "item": {
            "type": "message",
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": context
                }
            ]
        }
    }))

    # Käynnistä äänivaste tämän kontekstin perusteella
    await ws.send(json.dumps({"type": "response.create"}))

# Käyttäjä kysyy äänellä: "Lue viimeisin sähköpostini"
# Syötät sähköpostin sisällön tekstinä
await inject_text_context(ws, """
Tässä on viimeisin vastaanotettu sähköposti:
Lähettäjä: [email protected]
Aihe: Tarjouspyyntö
Sisältö: Hei, haluaisin pyytää tarjouksen
ääniavustajan integroinnista puhelinkeskukseemme.
""")

Kuvan näyttäminen ääniavustajalle

gpt-realtime-2.1 ja gpt-realtime-2 hyväksyvät syötteeksi tekstiä, ääntä ja kuvia. Kuva liitetään käyttäjän viestin input_image-osana Base64-muotoisena Data URI:na sekä WebSocketin että WebRTC-datakanavan yli. Malli huomioi tämän äänivasteessaan kutsumatta muita API:ita:

import base64
import json


async def montrer_image(ws, chemin_image: str, question: str) -> None:
    """Liittää kuvan ja kysymyksen keskusteluun ja pyytää äänivastetta."""
    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ä minun tulee maksaa ja mihin mennessä?")

Kuvista veloitetaan kuvatokeneina mallikortissa ilmoitetun hinnaston mukaisesti. Raskaaseen analyysiin tai kyvykkäämpään näkömalliin voit silti kysyä Responses API:ta erikseen ja syöttää sen tuloksen istuntoon: tee tämä system- tai user-viestinä (käyttäen input_text-sisältöä), älä koskaan väärennetyllä avustajan viestillä, jonka malli tulkitsisi omiksi sanoikseen.

Multimodaalinen verkkoliittymä

Verkkosovelluksessa yhdistä Realtime WebSocket visuaaliseen käyttöliittymään:

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

app = FastAPI()

@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
    """Multimodaalinen avustaja verkkoliittymällä."""
    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": "Multimodaalinen avustaja. Vastaa englanniksi.",
                "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":
                    # Välitä ääni
                    await openai_ws.send(json.dumps({
                        "type": "input_audio_buffer.append",
                        "audio": data["audio"]
                    }))

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

Multimodaalisia käyttötapauksia

Näin multimodaalinen avustaja hoitaa erilaisia skenaarioita function calling -työkalun avulla:

tools = [
    {
        "type": "function",
        "name": "show_chart",
        "description": "Näyttää käyttäjälle datakaavion",
        "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": "Lähettää asiakirjan asiakkaalle sähköpostitse",
        "parameters": {
            "type": "object",
            "properties": {
                "document_type": {"type": "string"},
                "recipient": {"type": "string"}
            },
            "required": ["document_type", "recipient"]
        }
    }
]

Käyttäjä sanoo äänellä: “Näytä viime vuosineljänneksen myynti kaaviona.” Avustaja kutsuu funktiota show_chart, frontendisi näyttää kaavion ja avustaja kommentoi tuloksia äänellä.

Keskeiset asiat

  • Realtime API tukee teksti- ja äänimodaliteetteja samanaikaisesti samassa istunnossa
  • Tekstin syöttäminen conversation.item.create:n avulla rikastuttaa äänikontekstia
  • Realtime-mallit hyväksyvät kuvia: liitä ne käyttäjän viestiin muodossa input_image
  • Työkalut (function calling) mahdollistavat visuaalisten elementtien näyttämisen samalla kun vastataan äänellä
  • Asiakaspuolen WebSocket-arkkitehtuuri mahdollistaa äänen, tekstin ja jäsennellyn datan yhdistämisen