Asystent głosowy multimodalny
Na tej stronie
Zaktualizowano 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie zostało wycofanych:
tts-1,tts-1-hdorazgpt-4o-mini-ttsprzestaną działać 6 stycznia 2027 (zalecanym zamiennikiem jestgpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez/v1/audio/speech: migracja syntezy mowy musi odbywać się przez Realtime API);gpt-realtime,gpt-4o-realtimeoraz starsze modele audio przestaną działać 20 stycznia 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoraz/v1/audio/translationsprzestaną działać 26 lutego 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pełnodupleksowa obsługa głosu przez GPT-Live 1 jest dostępna w API od 10 września 2026.
Skorygowano 3 listopada 2026. W poprzedniej wersji lekcji analiza obrazu wymagała osobnego wywołania Responses API, a następnie wstrzyknięcia opisu jako wiadomości asystenta z zawartością
input_text, co jest typem zarezerwowanym dla wiadomości użytkownika lub systemu. Jednak modelegpt-realtime-2.1igpt-realtime-2akceptują obrazy jako dane wejściowe: obraz dołączasz bezpośrednio jakoinput_imagedo wiadomości użytkownika. Zdarzenieresponse.text.deltaze starej wersji beta nosi teraz nazwęresponse.output_text.delta. Struktury zdarzeń zweryfikowano względem typów SDKopenaiw wersji 3.42.1. Źródła: Realtime conversations, Image inputs · gpt-realtime-2.1.
Asystent głosowy multimodalny
Asystent głosowy multimodalny łączy głos z innymi modalnościami: tekstem, obrazami, wideo i danymi strukturalnymi. Użytkownik mówi, ale agent może również wyświetlać informacje wizualne, analizować obrazy przesłane przez użytkownika lub łączyć wiele źródeł danych. To przyszłość interakcji człowiek-komputer.
Tekst i audio równolegle
Realtime API natywnie obsługuje jednocześnie modalności tekstowe i audio. Możesz wstrzyknąć tekst do rozmowy, zachowując przy tym wymianę głosową:
async def inject_text_context(ws, context: str):
"""Dodaje kontekst tekstowy do rozmowy głosowej."""
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": context
}
]
}
}))
# Uruchom odpowiedź głosową na podstawie tego kontekstu
await ws.send(json.dumps({"type": "response.create"}))
# Użytkownik mówi verbalnie: "Przeczytaj mi mojego najnowszego e-maila"
# Wstrzykujesz treść e-maila jako tekst
await inject_text_context(ws, """
Oto najnowszy otrzymany e-mail:
Od: [email protected]
Temat: Prośba o wycenę
Treść: Dzień dobry, chciałbym poprosić o wycenę
integracji agenta głosowego z naszym centrum obsługi klienta.
""")
Pokazywanie obrazu agentowi głosowemu
Modele gpt-realtime-2.1 i gpt-realtime-2 akceptują jako dane wejściowe tekst, audio i obrazy. Obraz dołączasz jako część input_image wiadomości użytkownika, używając URI danych Base64, zarówno przez WebSocket, jak i kanał danych WebRTC. Model uwzględnia to w swojej odpowiedzi głosowej bez konieczności wywoływania innego API:
import base64
import json
async def montrer_image(ws, chemin_image: str, question: str) -> None:
"""Dołącza obraz i pytanie do rozmowy, a następnie żąda odpowiedzi głosowej."""
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", "Co muszę zapłacić i do kiedy?")
Obrazy są rozliczane jako tokeny obrazowe według stawki określonej w karcie modelu. W przypadku zaawansowanej analizy lub gdy potrzebujesz bardziej wydajnego modelu wizyjnego, możesz nadal osobowo odpytywać Responses API, a następnie przekazać wynik do sesji: zrób to poprzez wiadomość system lub user (z zawartością input_text), nigdy poprzez fałszywą wiadomość asystenta, którą model zinterpretowałby jako własne słowa.
Multimodalny interfejs webowy
W aplikacji webowej połącz WebSocket Realtime z interfejsem wizualnym:
from fastapi import FastAPI, WebSocket
from fastapi.staticfiles import StaticFiles
app = FastAPI()
@app.websocket("/ws/agent")
async def multimodal_agent(client_ws: WebSocket):
"""Agent multimodalny z interfejsem webowym."""
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": "Asystent multimodalny. Odpowiadaj po angielsku.",
"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":
# Przekaż audio dalej
await openai_ws.send(json.dumps({
"type": "input_audio_buffer.append",
"audio": data["audio"]
}))
elif data["type"] == "text":
# Wiadomość tekstowa (czat)
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())
Przypadki użycia multimodalnego
Oto jak agent multimodalny obsługuje różne scenariusze w narzędziu wywoływania funkcji:
tools = [
{
"type": "function",
"name": "show_chart",
"description": "Wyświetla użytkownikowi wykres danych",
"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": "Wysyła dokument do klienta e-mailem",
"parameters": {
"type": "object",
"properties": {
"document_type": {"type": "string"},
"recipient": {"type": "string"}
},
"required": ["document_type", "recipient"]
}
}
]
Użytkownik mówi: „Pokaż mi sprzedaż z ostatniego kwartału na wykresie“. Agent wywołuje show_chart, Twój frontend wyświetla wykres, a agent ustnie komentuje wyniki.
Kluczowe wnioski
- Realtime API obsługuje jednocześnie modalności tekstowe i audio w tej samej sesji
- Wstrzykiwanie tekstu przez
conversation.item.createpozwala wzbogacić kontekst głosowy - Modele Realtime akceptują obrazy: dołączaj je jako
input_imagedo wiadomości użytkownika - Narzędzia (wywoływanie funkcji) pozwalają wyświetlać elementy wizualne podczas odpowiadania głosowo
- Architektura WebSocket po stronie klienta umożliwia mieszanie audio, tekstu i danych strukturalnych