Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Asistentas balsu su keliomis modalumais

Paskaita 16 iš 18 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Asistentas balsu su keliomis modalumais
  2. Tekstas ir garsas lygiagrečiai
  3. Vaizdo rodymas balsiniam agentui
  4. Tinklo sąsaja su keliomis modalumais
  5. Naudojimo atvejai su keliomis modalumais
  6. Svarbiausi punktai

Atnaujinta 2026 m. lapkričio 2 d. — Garso modeliai. Keli šio kurso modeliai yra pasenę: tts-1, tts-1-hd ir gpt-4o-mini-tts nustos veikti 2027 m. sausio 6 d. (nurodytas pakaitalas – gpt-realtime-2.1-mini, tačiau OpenAI TTS gide teigiama, kad jis nepalaikomas per /v1/audio/speech: kalbos sintezės migracija turi vykti per „Realtime API“); gpt-realtime, gpt-4o-realtime ir senieji garso modeliai nustos veikti 2027 m. sausio 20 d. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ir /v1/audio/translations nustos veikti 2027 m. vasario 26 d. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pilno dublekso (full-duplex) balsui GPT-Live 1 API yra prieinamas nuo 2026 m. rugsėjo 10 d.

Ištaisyta 2026 m. lapkričio 3 d. Anksčiau pamokoje vaizdui analizuoti buvo atliekamas atskiras užklausimas „Responses API“, o gautas aprašymas įterpiamas kaip asistento žinutė su input_text turiniu, nors šis tipas skirtas tik naudotojo ar sistemos žinutėms. Tačiau gpt-realtime-2.1 ir gpt-realtime-2 priima vaizdus kaip įvestį: vaizdas pridedamas tiesiogiai kaip input_image prie naudotojo žinutės. Senosios beta versijos response.text.delta įvykis dabar pervadintas į response.output_text.delta. Įvykių struktūros patikrintos pagal openai SDK tipus 3.42.1. Šaltiniai: Realtime conversations, Image inputs · gpt-realtime-2.1.

Asistentas balsu su keliomis modalumais

Asistentas balsu su keliomis modalumais sujungia balsą su kitais būdais: tekstu, vaizdais, vaizdo įrašais ir struktūrizuotais duomenimis. Naudotojas kalba, tačiau agentas taip pat gali rodyti vizualinę informaciją, analizuoti naudotojo atsiųstus vaizdus arba derinti kelis duomenų šaltinius. Tai yra žmogaus ir kompiuterio sąveikos ateitis.

Tekstas ir garsas lygiagrečiai

„Realtime API“ iš esmės palaiko teksto ir garso modalumus vienu metu. Pokalbio metu gali įterpti tekstą, tuo pačiu išlaikydamas balsinį bendravimą:

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.
""")

Vaizdo rodymas balsiniam agentui

gpt-realtime-2.1 ir gpt-realtime-2 kaip įvestį priima tekstą, garsą ir vaizdus. Vaizdas pridedamas kaip input_image naudotojo žinutės dalis, naudojant „Base64 Data URI“, tiek per „WebSocket“, tiek per „WebRTC“ duomenų kanalą. Modelis į tai atsižvelgia savo balsiniame atsakyme, nekviesti kito API:

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?")

Vaizdai apmokestinami kaip vaizdo tokenai, taikant konkrečią kainą, nurodytą modelio kortelėje. Sudėtingesnei analizei arba norint naudoti pajėgesnį regos modelį, vis dar gali atskirai kreiptis į „Responses API“, o tada perduoti jo rezultatą sesijai: tai daryk per system arba user žinutę (su input_text turiniu), niekada per netikrą asistento žinutę, kurią modelis interpretuotų kaip savo paties žodžius.

Tinklo sąsaja su keliomis modalumais

Tinklo programai derink „Realtime WebSocket“ su vizualine sąsaja:

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())

Naudojimo atvejai su keliomis modalumais

Štai kaip agentas su keliomis modalumais tvarko skirtingus scenarijus naudodamas funkcijų iškvietimo įrankį:

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

Naudotojas pasako: „Parodyk praėjusio ketvirčio pardavimus diagramoje.“ Agentas iškviečia show_chart, tavo sąsaja parodo diagramą, o agentas balsu pakomentuoja rezultatus.

Svarbiausi punktai

  • „Realtime API“ toje pačioje sesijoje vienu metu palaiko teksto ir garso modalumus
  • Teksto įterpimas per conversation.item.create leidžia praturtinti balsinį kontekstą
  • „Realtime“ modeliai priima vaizdus: pridėk juos kaip input_image prie naudotojo žinutės
  • Įrankiai (funkcijų iškvietimas) leidžia rodyti vizualinius elementus atsakant balsu
  • Kliento pusės „WebSocket“ architektūra leidžia maišyti garsą, tekstą ir struktūrizuotus duomenis