Przejdź do głównej treści
Polski— Wybierz język
Menu

Asystent głosowy multimodalny

Lekcja 16 z 18 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Asystent głosowy multimodalny
  2. Tekst i audio równolegle
  3. Pokazywanie obrazu agentowi głosowemu
  4. Multimodalny interfejs webowy
  5. Przypadki użycia multimodalnego
  6. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie zostało wycofanych: tts-1, tts-1-hd oraz gpt-4o-mini-tts przestaną działać 6 stycznia 2027 (zalecanym zamiennikiem jest gpt-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-realtime oraz 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-transcribe oraz /v1/audio/translations przestaną 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 modele gpt-realtime-2.1 i gpt-realtime-2 akceptują obrazy jako dane wejściowe: obraz dołączasz bezpośrednio jako input_image do wiadomości użytkownika. Zdarzenie response.text.delta ze starej wersji beta nosi teraz nazwę response.output_text.delta. Struktury zdarzeń zweryfikowano względem typów SDK openai w 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.create pozwala wzbogacić kontekst głosowy
  • Modele Realtime akceptują obrazy: dołączaj je jako input_image do 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