Salt la conținutul principal
Română— Alege o limbă
Meniu

Asistent vocal multimodal

Lecția 16 din 18 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Asistent vocal multimodal
  2. Text și audio în paralel
  3. Afișarea unei imagini către agentul vocal
  4. Interfață web multimodală
  5. Cazuri de utilizare multimodale
  6. Puncte cheie

Actualizat la 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate: tts-1, tts-1-hd și gpt-4o-mini-tts vor înceta să funcționeze la 6 ianuarie 2027 (înlocuitorul indicat este gpt-realtime-2.1-mini, pe care ghidul OpenAI TTS precizează că nu este suportat de /v1/audio/speech: migrarea sintezei vocale trebuie să treacă prin API-ul Realtime); gpt-realtime, gpt-4o-realtime și modelele audio legacy la 20 ianuarie 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe și /v1/audio/translations la 26 februarie 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pentru voce full-duplex, GPT-Live 1 este disponibil în API din 10 septembrie 2026.

Corectat la 3 noiembrie 2026. Pentru a analiza o imagine, lecția anterioară efectua un apel separat către API-ul Responses, apoi injecta descrierea ca mesaj de asistent cu conținut input_text, un tip rezervat mesajelor de utilizator sau de sistem. Totuși, gpt-realtime-2.1 și gpt-realtime-2 acceptă imagini ca intrare: imaginea este atașată direct, ca input_image, la un mesaj de utilizator. Evenimentul response.text.delta din vechea versiune beta se numește acum response.output_text.delta. Formele evenimentelor au fost verificate față de tipurile SDK openai 3.42.1. Surse: Conversații în timp real, Intrări de imagini · gpt-realtime-2.1.

Asistent vocal multimodal

Un asistent vocal multimodal combină vocea cu alte modalități: text, imagini, video și date structurate. Utilizatorul vorbește, dar agentul poate afișa și informații vizuale, poate analiza imagini trimise de utilizator sau poate combina multiple surse de date. Acesta este viitorul interacțiunii om-calculator.

Text și audio în paralel

API-ul Realtime suportă nativ simultan modalitățile text și audio. Puteți injecta text în conversație menținând în același timp schimbul vocal:

async def inject_text_context(ws, context: str):
    """Adaugă context textual conversației vocale."""
    await ws.send(json.dumps({
        "type": "conversation.item.create",
        "item": {
            "type": "message",
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": context
                }
            ]
        }
    }))

    # Declanșează un răspuns vocal bazat pe acest context
    await ws.send(json.dumps({"type": "response.create"}))

# Utilizatorul întreabă verbal „Citește-mi ultimul e-mail“
# Injectați conținutul e-mailului ca text
await inject_text_context(ws, """
Iată ultimul e-mail primit:
De la: [email protected]
Subiect: Cerere ofertă
Conținut: Bună ziua, aș dori să solicit o ofertă pentru
integrarea unui agent vocal în centrul nostru de apeluri.
""")

Afișarea unei imagini către agentul vocal

gpt-realtime-2.1 și gpt-realtime-2 acceptă text, audio și imagini ca intrare. O imagine este atașată ca parte input_image a unui mesaj de utilizator, folosind un URI de date Base64, atât prin WebSocket, cât și prin canalul de date WebRTC. Modelul ține cont de acest lucru în răspunsul său vocal, fără a apela un alt API:

import base64
import json


async def montrer_image(ws, chemin_image: str, question: str) -> None:
    """Atașează o imagine și o întrebare la conversație, apoi solicită un răspuns vocal."""
    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", "Ce trebuie să plătesc și până la ce dată?")

Imaginile sunt facturate ca tokeni de imagine, la o rată specifică listată pe fișa modelului. Pentru analize complexe sau pentru un model de viziune mai capabil, puteți interoga separat API-ul Responses, apoi să transmiteți rezultatul sesiunii: faceți acest lucru printr-un mesaj de system sau de user (cu conținut input_text), niciodată printr-un mesaj fals de asistent, pe care modelul l-ar interpreta ca fiind propriile sale cuvinte.

Interfață web multimodală

Pentru o aplicație web, combinați WebSocket-ul Realtime cu o interfață vizuală:

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

app = FastAPI()

@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
    """Agent multimodal cu interfață web."""
    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": "Asistent multimodal. Răspunde în engleză.",
                "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":
                    # Releu audio
                    await openai_ws.send(json.dumps({
                        "type": "input_audio_buffer.append",
                        "audio": data["audio"]
                    }))

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

Cazuri de utilizare multimodale

Iată cum gestionează un agent multimodal diferite scenarii într-un instrument de apelare de funcții:

tools = [
    {
        "type": "function",
        "name": "show_chart",
        "description": "Afișează un grafic de date utilizatorului",
        "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": "Trimite un document clientului prin e-mail",
        "parameters": {
            "type": "object",
            "properties": {
                "document_type": {"type": "string"},
                "recipient": {"type": "string"}
            },
            "required": ["document_type", "recipient"]
        }
    }
]

Utilizatorul spune verbal: „Afișează-mi vânzările trimestrului trecut sub formă de grafic.“ Agentul apelează show_chart, frontend-ul dumneavoastră afișează graficul, iar agentul comentează verbal rezultatele.

Puncte cheie

  • API-ul Realtime suportă simultan modalitățile text și audio în aceeași sesiune
  • Injectarea textului prin conversation.item.create vă permite să îmbogățiți contextul vocal
  • Modelele Realtime acceptă imagini: atașați-le ca input_image la un mesaj de utilizator
  • Instrumentele (apelarea de funcții) vă permit să afișați elemente vizuale în timp ce răspundeți verbal
  • Arhitectura WebSocket lato-client vă permite să amestecați audio, text și date structurate