Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Palīgs ar vairākiem datu veidiem un balss interfeisu

Nodarbība 16 no 18 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Palīgs ar vairākiem datu veidiem un balss interfeisu
  2. Teksts un audio paralēli
  3. Attēla parādīšana balss aģentam
  4. Daudzveidīgs tīmekļa interfeiss
  5. Daudzveidīgi lietojumi
  6. Galvenās atziņas

Atjaunināts 2026. gada 2. novembrī — Audio modeļi. Vairāki šī kursa modeļi ir novecojuši: tts-1, tts-1-hd un gpt-4o-mini-tts pārtrauks darboties 2027. gada 6. janvārī (norādītā aizstājējversija ir gpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata definē kā ** neatbalstītu priekš /v1/audio/speech**: runas sintēzes migrācijai ir jāizmanto Realtime API); gpt-realtime, gpt-4o-realtime un vecie audio modeļi tiks atslēgti 2027. gada 20. janvārī (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe un /v1/audio/translations — 2027. gada 26. februārī (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pilnīgai divpusējai balss komunikācijai GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra.

Labots 2026. gada 3. novembrī. Lai analizētu attēlu, iepriekšējā nodarbībā tika veikts atsevišķs izsaukums uz Responses API, pēc tam iegūtais apraksts tika ievietots kā asistenta ziņojums ar saturu input_text, kas ir tips, paredzēts tikai lietotāja vai sistēmas ziņojumiem. Tomēr gpt-realtime-2.1 un gpt-realtime-2 pieņem attēlus kā ievadi: attēls tiek pievienots tieši kā input_image lietotāja ziņojumam. Notikums response.text.delta no vecās beta versijas tagad ir pārdēvēts par response.output_text.delta. Notikumu struktūras pārbaudītas pret openai SDK tipiem 3.42.1. Avoti: Realtime conversations, Image inputs · gpt-realtime-2.1.

Palīgs ar vairākiem datu veidiem un balss interfeisu

Palīgs, kas apvieno balss saziņu ar citiem datu veidiem (modalitātēm), integrē balsi ar tekstu, attēliem, video un strukturētiem datiem. Lietotājs runā, bet aģents spēj arī parādīt vizuālu informāciju, analizēt lietotāja nosūtītus attēlus vai apvienot vairākus datu avotus. Tāda ir cilvēka un datora mijiedarbības nākotne.

Teksts un audio paralēli

Realtime API dabiski atbalsta teksta un audio modalitātes vienlaicīgi. Sarunas laikā vari ievadīt tekstu, vienlaikus uzturot balss apmaiņu:

async def inject_text_context(ws, context: str):
    """Pievieno teksta kontekstu balss sarunai."""
    await ws.send(json.dumps({
        "type": "conversation.item.create",
        "item": {
            "type": "message",
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": context
                }
            ]
        }
    }))

    # Ģenerē balss atbildi, pamatojoties uz šo kontekstu
    await ws.send(json.dumps({"type": "response.create"}))

# Lietotājs mutiski jautā: "Izlasi man jaunāko e-pastu"
# Tu ievadi e-pasta saturu kā tekstu
await inject_text_context(ws, """
Šeit ir jaunākais saņemtais e-pasts:
No: [email protected]
Tēma: Piedāvājuma pieprasījums
Saturs: Sveiki, vēlos pieprasīt piedāvājumu
balss aģenta integrēšanai mūsu zvanu centrā.
""")

Attēla parādīšana balss aģentam

Modeļi gpt-realtime-2.1 un gpt-realtime-2 kā ievadi pieņem tekstu, audio un attēlus. Attēls tiek pievienots kā input_image daļa lietotāja ziņojumā, izmantojot Base64 Data URI, gan caur WebSocket, gan WebRTC datu kanālu. Models to ņem vērā savā balss atbildē, neizsaucot citu API:

import base64
import json


async def montrer_image(ws, chemin_image: str, question: str) -> None:
    """Pievieno attēlu un jautājumu sarunai, pēc tam pieprasa balss atbildi."""
    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", "Kas man jāsamaksā un līdz kuram datumam?")

Par attēliem tiek iekasēta maksa kā par attēla tokeniem atbilstoši modeļa aprakstā norādītajai likme. Sarežģītākai analīzei vai ja nepieciešams jaudīgāks redzes models, vari atsevišķi izsaukt Responses API, pēc tam nodot tā rezultātu sesijai: dari to caur system vai user ziņojumu (ar saturu input_text), nekad neizmantojot viltotu asistenta ziņojumu, ko models interpretētu kā savu paša teikto.

Daudzveidīgs tīmekļa interfeiss

Tīmekļa lietotnei apvieno Realtime WebSocket ar vizuālo interfeisu:

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

app = FastAPI()

@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
    """Daudzveidīgs aģents ar tīmekļa interfeisu."""
    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": "Daudzveidīgs palīgs. Atbildi angļu valodā.",
                "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":
                    # Pārsūta audio
                    await openai_ws.send(json.dumps({
                        "type": "input_audio_buffer.append",
                        "audio": data["audio"]
                    }))

                elif data["type"] == "text":
                    # Teksta ziņojums (čats)
                    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())

Daudzveidīgi lietojumi

Lūk, kā daudzveidīgs aģents izturas pret dažādiem scenārijiem, izmantojot funkciju izsaukšanas rīku:

tools = [
    {
        "type": "function",
        "name": "show_chart",
        "description": "Parāda lietotājam datu diagrammu",
        "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": "Nosūta dokumentu klientam pa e-pastu",
        "parameters": {
            "type": "object",
            "properties": {
                "document_type": {"type": "string"},
                "recipient": {"type": "string"}
            },
            "required": ["document_type", "recipient"]
        }
    }
]

Lietotājs saka: „Parādi man pagājušā ceturkšņa pārdošanas rezultātus diagrammā.” Aģents izsauc show_chart, tavs frontends parāda diagrammu, un aģents mutiski komentē rezultātus.

Galvenās atziņas

  • Realtime API vienā sesijā vienlaicīgi atbalsta teksta un audio modalitātes
  • Teksta ievade, izmantojot conversation.item.create, ļauj bagātināt balss kontekstu
  • Realtime modeļi pieņem attēlus: pievieno tos kā input_image lietotāja ziņojumam
  • Rīki (funkciju izsaukšana) ļauj parādīt vizuālus elementus, vienlaikus sniedzot balss atbildi
  • Klienta puses WebSocket arhitektūra ļauj sajaukt audio, tekstu un strukturētus datus