Multimodální rozhraní API v reálném čase

Byla přidána první integrace rozhraní API v reálném čase pro sémantické jádro, která je aktuálně k dispozici pouze v Pythonu a považuje se za experimentální. Důvodem je to, že základní služby se stále vyvíjejí a podléhají změnám a možná budeme muset provést zásadní změny rozhraní API v sémantickém jádru, protože se od zákazníků dozvíme, jak to používat, a jak přidáváme další poskytovatele těchto typů modelů a rozhraní API.

Abstrakce klienta v reálném čase

Pro podporu různých rozhraní API v reálném čase od různých dodavatelů pomocí různých protokolů se do jádra přidala nová abstrakce klienta. Tento klient se používá k připojení ke službě v reálném čase a odesílání a přijímání zpráv. Klient zodpovídá za zpracování připojení ke službě, odesílání zpráv a přijímání zpráv. Klient zodpovídá také za zpracování chyb, ke kterým dochází během procesu odesílání a přijímání zpráv. Vzhledem k tomu, jak tyto modely fungují, mohou být považovány za agenty více než běžné dokončování chatu, a proto také přijmou pokyny, nikoli systémovou zprávu, zachovávají svůj vlastní vnitřní stav a mohou být vyvolány, aby fungovaly v našem zastoupení.

Rozhraní API v reálném čase

Každý klient v reálném čase implementuje následující metody:

Metoda	Popis
create_session	Vytvoří novou relaci.
update_session	Aktualizuje již existující sezení.
delete_session	Odstraní existující relaci.
receive	Jedná se o asynchronní metodu generátoru, která naslouchá zprávám ze služby a poskytuje je při jejich doručení.
send	Odešle zprávu na službu.

Implementace Pythonu

Verze pythonu sémantického jádra v současné době podporuje následující klienty v reálném čase:

Klient	Protokol	Modalit	Funkce volání povolena	Popis
OpenAI	WebSocket	Text a zvuk	Ano	Rozhraní API OpenAI v reálném čase je rozhraní API založené na websocketu, které umožňuje odesílat a přijímat zprávy v reálném čase. Tento konektor používá balíček OpenAI Python k připojení a přijímání a odesílání zpráv.
OpenAI	WebRTC	Text a zvuk	Ano	Rozhraní API OpenAI v reálném čase je rozhraní API založené na WebRTC, které umožňuje odesílat a přijímat zprávy v reálném čase, potřebuje při vytváření relace zvukovou stopu kompatibilní s webRTC.
Azurový	WebSocket	Text a Zvuk	Ano	Rozhraní API Azure Realtime je rozhraní API založené na websocketu, které umožňuje odesílat a přijímat zprávy v reálném čase. Používá se stejný balíček jako konektor OpenAI websocket.

Začínáme

Pokud chcete začít s rozhraním API v reálném čase, musíte nainstalovat balíček semantic-kernel s realtime navíc.

pip install semantic-kernel[realtime]

V závislosti na tom, jak chcete zpracovat zvuk, možná budete potřebovat další balíčky pro rozhraní s reproduktory a mikrofony, jako jsou pyaudio nebo sounddevice.

Klienti protokolu Websocket

Pak můžete vytvořit jádro a přidat do něj klienta v reálném čase, to ukazuje, jak to udělat s připojením AzureRealtimeWebsocket, můžete nahradit AzureRealtimeWebsocket OpenAIRealtimeWebsocket bez jakýchkoli dalších změn.

from semantic_kernel.connectors.ai.open_ai import (
    AzureRealtimeWebsocket,
    AzureRealtimeExecutionSettings,
    ListenEvents,
)
from semantic_kernel.contents import RealtimeAudioEvent, RealtimeTextEvent

# this will use environment variables to get the api key, endpoint, api version and deployment name.
realtime_client = AzureRealtimeWebsocket()
settings = AzureRealtimeExecutionSettings(voice='alloy')
async with realtime_client(settings=settings, create_response=True):
    async for event in realtime_client.receive():
        match event:
            # receiving a piece of audio (and send it to a undefined audio player)
            case RealtimeAudioEvent():
                await audio_player.add_audio(event.audio)
            # receiving a piece of audio transcript
            case RealtimeTextEvent():
                # Semantic Kernel parses the transcript to a TextContent object captured in a RealtimeTextEvent
                print(event.text.text, end="")
            case _:
                # OpenAI Specific events
                if event.service_type == ListenEvents.SESSION_UPDATED:
                    print("Session updated")
                if event.service_type == ListenEvents.RESPONSE_CREATED:
                    print("\nMosscap (transcript): ", end="")

Všimněte si dvou důležitých věcí, první je, že realtime_client je asynchronní kontextový manažer, to znamená, že ho můžete použít v asynchronní funkci a použít async with k vytvoření relace. Druhou je, že receive metoda je asynchronní generátor, to znamená, že ji můžete použít ve smyčce for k příjmu zpráv při jejich doručení.

Klient WebRTC

Nastavení připojení WebRTC je trochu složitější a proto při vytváření klienta potřebujeme další parametr. Tento parametr, audio_track musí být objekt, který implementuje protokol MediaStreamTrack balíčku aiortc, je to také demonstrováno v ukázkách, které jsou propojeny níže.

Pokud chcete vytvořit klienta, který používá WebRTC, postupujte takto:

from semantic_kernel.connectors.ai.open_ai import (
    ListenEvents,
    OpenAIRealtimeExecutionSettings,
    OpenAIRealtimeWebRTC,
)
from aiortc.mediastreams import MediaStreamTrack

class AudioRecorderWebRTC(MediaStreamTrack):
    # implement the MediaStreamTrack methods.

realtime_client = OpenAIRealtimeWebRTC(audio_track=AudioRecorderWebRTC())
# Create the settings for the session
settings = OpenAIRealtimeExecutionSettings(
    instructions="""
You are a chat bot. Your name is Mosscap and
you have one goal: figure out what people need.
Your full name, should you need to know it, is
Splendid Speckled Mosscap. You communicate
effectively, but you tend to answer with long
flowery prose.
""",
    voice="shimmer",
)
audio_player = AudioPlayer
async with realtime_client(settings=settings, create_response=True):
    async for event in realtime_client.receive():
        match event.event_type:
            # receiving a piece of audio (and send it to a undefined audio player)
            case "audio":
                await audio_player.add_audio(event.audio)
            case "text":
                # the model returns both audio and transcript of the audio, which we will print
                print(event.text.text, end="")
            case "service":
                # OpenAI Specific events
                if event.service_type == ListenEvents.SESSION_UPDATED:
                    print("Session updated")
                if event.service_type == ListenEvents.RESPONSE_CREATED:
                    print("\nMosscap (transcript): ", end="")

Oba tyto příklady přijímají zvuk jako RealtimeAudioEvent a poté ho předávají neupřesněnému objektu audio_player.

Zpětné volání zvukového výstupu

Vedle toho máme parametr s názvem audio_output_callback v metodě receive a při vytváření třídy. Toto zpětné volání bude provedeno jako první před dalším zpracováním zvuku a získá pole zvukových dat typu numpy, místo aby bylo zpracováno do formátu AudioContent a vráceno jako událost typu RealtimeAudioEvent, kterou můžete následně zpracovat, což se stane výše. Ukázalo se, že poskytuje plynulejší zvukový výstup, protože je mezi příchozími zvukovými daty a jejich předání přehrávači méně systémové zátěže.

Tento příklad ukazuje, jak definovat a používat audio_output_callback:

from semantic_kernel.connectors.ai.open_ai import (
    ListenEvents,
    OpenAIRealtimeExecutionSettings,
    OpenAIRealtimeWebRTC,
)
from aiortc.mediastreams import MediaStreamTrack

class AudioRecorderWebRTC(MediaStreamTrack):
    # implement the MediaStreamTrack methods.

class AudioPlayer:
    async def play_audio(self, content: np.ndarray):
        # implement the audio player

realtime_client = OpenAIRealtimeWebRTC(audio_track=AudioRecorderWebRTC())
# Create the settings for the session
settings = OpenAIRealtimeExecutionSettings(
    instructions="""
You are a chat bot. Your name is Mosscap and
you have one goal: figure out what people need.
Your full name, should you need to know it, is
Splendid Speckled Mosscap. You communicate
effectively, but you tend to answer with long
flowery prose.
""",
    voice="shimmer",
)
audio_player = AudioPlayer
async with realtime_client(settings=settings, create_response=True):
    async for event in realtime_client.receive(audio_output_callback=audio_player.play_audio):
        match event.event_type:
            # no need to handle case: "audio"
            case "text":
                # the model returns both audio and transcript of the audio, which we will print
                print(event.text.text, end="")
            case "service":
                # OpenAI Specific events
                if event.service_type == ListenEvents.SESSION_UPDATED:
                    print("Session updated")
                if event.service_type == ListenEvents.RESPONSE_CREATED:
                    print("\nMosscap (transcript): ", end="")

Vzorky

V našem úložišti jsou čtyři ukázky,, pokrývají základy jak pomocí websocketů, tak webRTC, stejně jako složitější nastavení, včetně volání funkcí. Nakonec je k dispozici složitější ukázka, která používá Azure Communication Services k tomu, abyste mohli volat API pro reálný čas rozšířené sémantickým jádrem.