Asistent vocal multimodal
Pe această pagină
Actualizat la 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate:
tts-1,tts-1-hdșigpt-4o-mini-ttsvor înceta să funcționeze la 6 ianuarie 2027 (înlocuitorul indicat estegpt-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/translationsla 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șigpt-realtime-2acceptă imagini ca intrare: imaginea este atașată direct, cainput_image, la un mesaj de utilizator. Evenimentulresponse.text.deltadin vechea versiune beta se numește acumresponse.output_text.delta. Formele evenimentelor au fost verificate față de tipurile SDKopenai3.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.createvă permite să îmbogățiți contextul vocal - Modelele Realtime acceptă imagini: atașați-le ca
input_imagela 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