Interfejs API GPT Realtime dla mowy i dźwięku

Uwaga / Notatka

Ten dokument odnosi się do portalu Microsoft Foundry (klasycznego).

🔄 Przejdź do dokumentacji Microsoft Foundry (nowej), jeśli korzystasz z nowego portalu.

Uwaga / Notatka

Ten dokument odnosi się do portalu Microsoft Foundry (nowy).

Interfejs API usługi Azure OpenAI GPT Realtime dla mowy i dźwięku jest częścią rodziny modeli GPT-4o, która obsługuje interakcje konwersacyjne "mowa w, wypowiedź".

Interfejs API czasu rzeczywistego można użyć za pośrednictwem protokołu WebRTC lub WebSocket, aby wysyłać dane wejściowe audio do modelu i odbierać odpowiedzi audio w czasie rzeczywistym.

Postępuj zgodnie z instrukcjami tego artykułu, aby rozpocząć pracę z API czasu rzeczywistego za pośrednictwem WebSockets. Korzystaj z interfejsu API czasu rzeczywistego przez WebSockety w scenariuszach serwer-serwer, gdzie niski poziom opóźnień nie jest wymagany.

Wskazówka

W większości przypadków zalecamy użycie interfejsu API czasu rzeczywistego za pośrednictwem usługi WebRTC na potrzeby przesyłania strumieniowego audio w czasie rzeczywistym w aplikacjach po stronie klienta, takich jak aplikacja internetowa lub aplikacja mobilna. WebRTC został zaprojektowany do przesyłania strumieniowego audio o niskim opóźnieniu w czasie rzeczywistym i jest najlepszym wyborem w większości przypadków użycia.

Obsługiwane modele

Modele GPT w czasie rzeczywistym są dostępne dla wdrożeń globalnych.

gpt-4o-realtime-preview (wersja 2024-12-17)
gpt-4o-mini-realtime-preview (wersja 2024-12-17)
gpt-realtime (wersja 2025-08-28)
gpt-realtime-mini (wersja 2025-10-06)
gpt-realtime-mini-2025-12-15 (wersja 2025-12-15)

Aby uzyskać więcej informacji, zobacz dokumentację modeli i wersji.

Obsługa interfejsu API

Obsługa interfejsu API w czasie rzeczywistym została po raz pierwszy dodana w wersji 2024-10-01-preview (wycofanej). Użyj wersji 2025-08-28 , aby uzyskać dostęp do najnowszych funkcji interfejsu API czasu rzeczywistego. Zalecamy wybranie ogólnie dostępnej wersji interfejsu API (bez sufiksu "-preview"), jeśli jest to możliwe.

Ostrzeżenie

Musisz użyć różnych formatów punktów końcowych dla modeli w wersji zapoznawczej i ogólnie dostępnej (GA). Wszystkie przykłady w tym artykule używają modeli GA i formatu punktu końcowego GA, nie używając parametru api-version, który jest wymagany tylko w wersji roboczej formatu punktu końcowego. Zobacz szczegółowe informacje na temat formatu punktu końcowego w tym artykule.

Wymagania wstępne

Subskrypcja platformy Azure - Utwórz ją za darmo
obsługa Node.js LTS lub ESM.
Zasób usługi Azure OpenAI utworzony w jednym z obsługiwanych regionów. Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.
Następnie należy wdrożyć gpt-realtime model przy użyciu zasobu usługi Azure OpenAI. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu i wdrażanie modelu za pomocą usługi Azure OpenAI.

Wymagania wstępne dotyczące Microsoft Entra ID

W przypadku zalecanego uwierzytelniania bez klucza za pomocą identyfikatora Entra firmy Microsoft należy wykonać następujące czynności:

Zainstaluj Azure CLI używane do uwierzytelniania bezkluczowego za pomocą Microsoft Entra ID.
Cognitive Services OpenAI User Przypisz rolę do konta użytkownika. Role można przypisać w portalu Azure w sekcji Kontrola dostępu (IAM)>Dodawanie przypisania roli.

Wdrażanie modelu na potrzeby dźwięku w czasie rzeczywistym

Aby wdrożyć gpt-realtime model w portalu Microsoft Foundry:

Przejdź do portalu Foundry i utwórz lub wybierz projekt.
Wybierz wdrożenia modelu:
1. W polu Zasób usługi Azure OpenAI wybierz pozycję Wdrożenia w sekcji Zasoby udostępnione w okienku po lewej stronie.
2. W zasobie Foundry wybierz Modele i punkty końcowe z sekcji Moje zasoby po lewej stronie.
Wybierz pozycję + Wdróż model>podstawowy, aby otworzyć okno wdrażania.
Wyszukaj i wybierz gpt-realtime model, a następnie wybierz pozycję Potwierdź.
Przejrzyj szczegóły wdrożenia i wybierz pozycję Wdróż.
Postępuj zgodnie z instrukcjami kreatora, aby zakończyć wdrażanie modelu.

Teraz, gdy masz wdrożenie gpt-realtime modelu, możesz korzystać z niego w portalu Foundry, w placu zabaw Audio lub API w czasie rzeczywistym.

Ustawienia

Utwórz nowy folder realtime-audio-quickstart-js i przejdź do folderu Szybki start za pomocą następującego polecenia:
```
mkdir realtime-audio-quickstart-js && cd realtime-audio-quickstart-js
```
Utwórz element package.json za pomocą następującego polecenia:
```
npm init -y
```
Zaktualizuj type na module w package.json za pomocą następującego polecenia.
```
npm pkg set type=module
```
Zainstaluj bibliotekę klienta openAI dla języka JavaScript za pomocą następujących narzędzi:
```
npm install openai
```
Zainstaluj pakiety zależne używane przez bibliotekę klienta OpenAI dla języka JavaScript za pomocą następujących narzędzi:
```
npm install ws
```
Aby uzyskać zalecane uwierzytelnianie bez klucza za pomocą identyfikatora Entra firmy Microsoft, zainstaluj pakiet za @azure/identity pomocą polecenia:
```
npm install @azure/identity
```

Pobieranie informacji o zasobie

Aby uwierzytelnić aplikację przy użyciu zasobu usługi Azure OpenAI, musisz pobrać następujące informacje:

Microsoft Entra ID
Klucz interfejsu API

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.

Dowiedz się więcej na temat uwierzytelniania bez klucza i ustawiania zmiennych środowiskowych.

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_API_KEY`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal. Możesz użyć wartości `KEY1` lub `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.

Dowiedz się więcej na temat znajdowania kluczy interfejsu API i ustawiania zmiennych środowiskowych.

Ważne

Używaj kluczy interfejsu API z ostrożnością. Nie dołączaj klucza interfejsu API bezpośrednio do kodu i nigdy nie publikuj go publicznie. Jeśli używasz klucza interfejsu API, zapisz go bezpiecznie w usłudze Azure Key Vault. Aby uzyskać więcej informacji na temat bezpiecznego używania kluczy interfejsu API w aplikacjach, zobacz Klucze interfejsu API w usłudze Azure Key Vault.

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Ostrzeżenie

Aby użyć zalecanego uwierzytelniania bez klucza z zestawem SDK, upewnij się, że zmienna AZURE_OPENAI_API_KEY środowiskowa nie jest ustawiona.

index.js Utwórz plik przy użyciu następującego kodu:

import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';
import { DefaultAzureCredential, getBearerTokenProvider } from '@azure/identity';
import { OpenAIRealtimeError } from 'openai/realtime/internal-base';

let isCreated = false;
let isConfigured = false;
let responseDone = false;

// Set this to false, if you want to continue receiving events after an error is received.
const throwOnError = true;

async function main() {
    // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    // environment variable or replace the default value below.
    // You can find it in the Microsoft Foundry portal in the Overview page of your Azure OpenAI resource.
    // Example: https://{your-resource}.openai.azure.com
    const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
    const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';

    // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    // Example: gpt-realtime
    const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';

    // Keyless authentication
    const credential = new DefaultAzureCredential();
    const scope = 'https://cognitiveservices.azure.com/.default';
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const token = await azureADTokenProvider();

    // The APIs are compatible with the OpenAI client library.
    // You can use the OpenAI client library to access the Azure OpenAI APIs.
    // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    const openAIClient = new OpenAI({
        baseURL: baseUrl,
        apiKey: token,
    });
    const realtimeClient = await OpenAIRealtimeWS.create(openAIClient, {
        model: deploymentName
    });

    realtimeClient.on('error', (receivedError) => receiveError(receivedError));
    realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));

    console.log('Waiting for events...');
    while (!isCreated) {
        console.log('Waiting for session.created event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is created, configure it to enable audio input and output.
    const sessionConfig = {
        'type': 'realtime',
        'instructions': 'You are a helpful assistant. You respond by voice and text.',
        'output_modalities': ['audio'],
        'audio': {
            'input': {
                'transcription': {
                    'model': 'whisper-1'
                },
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                },
                'turn_detection': {
                    'type': 'server_vad',
                    'threshold': 0.5,
                    'prefix_padding_ms': 300,
                    'silence_duration_ms': 200,
                    'create_response': true
                }
            },
            'output': {
                'voice': 'alloy',
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                }
            }
        }
    };

    realtimeClient.send({
        'type': 'session.update',
        'session': sessionConfig
    });
    while (!isConfigured) {
        console.log('Waiting for session.updated event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is configured, data can be sent to the session.    
    realtimeClient.send({
        'type': 'conversation.item.create',
        'item': {
            'type': 'message',
            'role': 'user',
            'content': [{
                type: 'input_text',
                text: 'Please assist the user.'
            }
            ]
        }
    });

    realtimeClient.send({
        type: 'response.create'
    });



    // While waiting for the session to finish, the events can be handled in the event handlers.
    // In this example, we just wait for the first response.done event.
    while (!responseDone) {
        console.log('Waiting for response.done event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    console.log('The sample completed successfully.');
    realtimeClient.close();
}

function receiveError(err) {
    if (err instanceof OpenAIRealtimeError) {
        console.error('Received an error event.');
        console.error(`Message: ${err.cause.message}`);
        console.error(`Stack: ${err.cause.stack}`);
    }

    if (throwOnError) {
        throw err;
    }
}

function receiveEvent(event) {
    console.log(`Received an event: ${event.type}`);

    switch (event.type) {
        case 'session.created':
            console.log(`Session ID: ${event.session.id}`);
            isCreated = true;
            break;
        case 'session.updated':
            console.log(`Session ID: ${event.session.id}`);
            isConfigured = true;
            break;
        case 'response.output_audio_transcript.delta':
            console.log(`Transcript delta: ${event.delta}`);
            break;
        case 'response.output_audio.delta':
            let audioBuffer = Buffer.from(event.delta, 'base64');
            console.log(`Audio delta length: ${audioBuffer.length} bytes`);
            break;
        case 'response.done':
            console.log(`Response ID: ${event.response.id}`);
            console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
            responseDone = true;
            break;
        default:
            console.warn(`Unhandled event type: ${event.type}`);
    }
}

main().catch((err) => {
    console.error('The sample encountered an error:', err);
});
export {
    main
};

Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom plik JavaScript.
```
node index.js
```

index.js Utwórz plik przy użyciu następującego kodu:

import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';
import { OpenAIRealtimeError } from 'openai/realtime/internal-base';

let isCreated = false;
let isConfigured = false;
let responseDone = false;

// Set this to false, if you want to continue receiving events after an error is received.
const throwOnError = true;

async function main() {
    // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    // Example: https://{your-resource}.openai.azure.com
    const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
    const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';

    // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    // Example: gpt-realtime
    const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';

    // API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    const token = process.env.AZURE_OPENAI_API_KEY || '<Your API Key>';

    // The APIs are compatible with the OpenAI client library.
    // You can use the OpenAI client library to access the Azure OpenAI APIs.
    // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    const openAIClient = new OpenAI({
        baseURL: baseUrl,
        apiKey: token,
    });

    // Due to the current SDK limitation we need to explicitly
    // pass API key as Header
    const realtimeClient = await OpenAIRealtimeWS.create(
        openAIClient, {
        model: deploymentName,
        options: {
            headers: {
                "api-key": token
            }
        }
    });

    realtimeClient.on('error', (receivedError) => receiveError(receivedError));
    realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));

    console.log('Waiting for events...');
    while (!isCreated) {
        console.log('Waiting for session.created event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is created, configure it to enable audio input and output.
    const sessionConfig = {
        'type': 'realtime',
        'instructions': 'You are a helpful assistant. You respond by voice and text.',
        'output_modalities': ['audio'],
        'audio': {
            'input': {
                'transcription': {
                    'model': 'whisper-1'
                },
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                },
                'turn_detection': {
                    'type': 'server_vad',
                    'threshold': 0.5,
                    'prefix_padding_ms': 300,
                    'silence_duration_ms': 200,
                    'create_response': true
                }
            },
            'output': {
                'voice': 'alloy',
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                }
            }
        }
    };

    realtimeClient.send({
        'type': 'session.update',
        'session': sessionConfig
    });
    while (!isConfigured) {
        console.log('Waiting for session.updated event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is configured, data can be sent to the session.
    realtimeClient.send({
        'type': 'conversation.item.create',
        'item': {
            'type': 'message',
            'role': 'user',
            'content': [{
                type: 'input_text',
                text: 'Please assist the user.'
            }
            ]
        }
    });

    realtimeClient.send({
        type: 'response.create'
    });

    // While waiting for the session to finish, the events can be handled in the event handlers.
    // In this example, we just wait for the first response.done event.
    while (!responseDone) {
        console.log('Waiting for response.done event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    console.log('The sample completed successfully.');
    realtimeClient.close();
}

function receiveError(err) {
    if (err instanceof OpenAIRealtimeError) {
        console.error('Received an error event.');
        console.error(`Message: ${err.cause.message}`);
        console.error(`Stack: ${err.cause.stack}`);
    }

    if (throwOnError) {
        throw err;
    }
}

function receiveEvent(event) {
    console.log(`Received an event: ${event.type}`);

    switch (event.type) {
        case 'session.created':
            console.log(`Session ID: ${event.session.id}`);
            isCreated = true;
            break;
        case 'session.updated':
            console.log(`Session ID: ${event.session.id}`);
            isConfigured = true;
            break;
        case 'response.output_audio_transcript.delta':
            console.log(`Transcript delta: ${event.delta}`);
            break;
        case 'response.output_audio.delta':
            let audioBuffer = Buffer.from(event.delta, 'base64');
            console.log(`Audio delta length: ${audioBuffer.length} bytes`);
            break;
        case 'response.done':
            console.log(`Response ID: ${event.response.id}`);
            console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
            responseDone = true;
            break;
        default:
            console.warn(`Unhandled event type: ${event.type}`);
    }
}

main().catch((err) => {
    console.error('The sample encountered an error:', err);
});
export {
    main
};

Uruchom plik JavaScript.
```
node index.js
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Wynik

Skrypt pobiera odpowiedź z modelu i wyświetla odebrane dane transkrypcji i audio.

Dane wyjściowe będą wyglądać podobnie do następujących:

Waiting for events...
Waiting for session.created event...
Received an event: session.created
Session ID: sess_CQx8YO3vKxD9FaPxrbQ9R
Waiting for session.updated event...
Received an event: session.updated
Session ID: sess_CQx8YO3vKxD9FaPxrbQ9R
Waiting for response.done event...
Waiting for response.done event...
Waiting for response.done event...
Received an event: response.output_audio_transcript.delta
Transcript delta: Sure
Received an event: response.output_audio_transcript.delta
Transcript delta: ,
Received an event: response.output_audio_transcript.delta
Transcript delta:  I
Waiting for response.done event...
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 4800 bytes
Received an event: response.output_audio.delta
Audio delta length: 7200 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta: 'm
Received an event: response.output_audio_transcript.delta
Transcript delta:  here
Received an event: response.output_audio_transcript.delta
Transcript delta:  to
Received an event: response.output_audio_transcript.delta
Transcript delta:  help
Received an event: response.output_audio_transcript.delta
Transcript delta: .
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  What
Received an event: response.output_audio_transcript.delta
Transcript delta:  do
Received an event: response.output_audio_transcript.delta
Transcript delta:  you
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  need
Received an event: response.output_audio_transcript.delta
Transcript delta:  assistance
Received an event: response.output_audio_transcript.delta
Transcript delta:  with
Received an event: response.output_audio_transcript.delta
Transcript delta: ?
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 28800 bytes
Received an event: response.done
Response ID: resp_CQx8YwQCszDqSUXRutxP9
The final response is: Sure, I'm here to help. What do you need assistance with?
The sample completed successfully.

Wymagania wstępne

Subskrypcja platformy Azure. Utwórz je bezpłatnie.
Python 3.8 lub nowszy. Zalecamy używanie języka Python w wersji 3.10 lub nowszej, ale wymagana jest co najmniej wersja python 3.8. Jeśli nie masz zainstalowanej odpowiedniej wersji języka Python, możesz postępować zgodnie z instrukcjami w samouczku języka Python programu VS Code, aby uzyskać najprostszy sposób instalowania języka Python w systemie operacyjnym.
Zasób usługi Azure OpenAI utworzony w jednym z obsługiwanych regionów. Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.
Następnie należy wdrożyć model gpt-realtime, gpt-realtime-mini lub gpt-realtime-mini-2025-12-15 wraz z zasobem usługi Azure OpenAI. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu i wdrażanie modelu za pomocą usługi Azure OpenAI.

Wymagania wstępne dotyczące Microsoft Entra ID

W przypadku zalecanego uwierzytelniania bez klucza za pomocą identyfikatora Entra firmy Microsoft należy wykonać następujące czynności:

Zainstaluj Azure CLI używane do uwierzytelniania bezkluczowego za pomocą Microsoft Entra ID.
Cognitive Services OpenAI User Przypisz rolę do konta użytkownika. Role można przypisać w portalu Azure w sekcji Kontrola dostępu (IAM)>Dodawanie przypisania roli.

Wdrażanie modelu na potrzeby dźwięku w czasie rzeczywistym

Aby wdrożyć gpt-realtime model w portalu Microsoft Foundry:

Przejdź do portalu Foundry i utwórz lub wybierz projekt.
Wybierz wdrożenia modelu:
1. W polu Zasób usługi Azure OpenAI wybierz pozycję Wdrożenia w sekcji Zasoby udostępnione w okienku po lewej stronie.
2. W zasobie Foundry wybierz Modele i punkty końcowe z sekcji Moje zasoby po lewej stronie.
Wybierz pozycję + Wdróż model>podstawowy, aby otworzyć okno wdrażania.
Wyszukaj i wybierz gpt-realtime model, a następnie wybierz pozycję Potwierdź.
Przejrzyj szczegóły wdrożenia i wybierz pozycję Wdróż.
Postępuj zgodnie z instrukcjami kreatora, aby zakończyć wdrażanie modelu.

Teraz, gdy masz wdrożenie gpt-realtime modelu, możesz korzystać z niego w portalu Foundry, w placu zabaw Audio lub API w czasie rzeczywistym.

Ustawienia

Utwórz nowy folder realtime-audio-quickstart-py i przejdź do folderu Szybki start za pomocą następującego polecenia:
```
mkdir realtime-audio-quickstart-py && cd realtime-audio-quickstart-py
```
Tworzenie środowiska wirtualnego. Jeśli masz już zainstalowany język Python w wersji 3.10 lub nowszej, możesz utworzyć środowisko wirtualne przy użyciu następujących poleceń:
- Windows
- Linux
- macOS
```
py -3 -m venv .venv
.venv\scripts\activate
```
```
python3 -m venv .venv
source .venv/bin/activate
```
```
python3 -m venv .venv
source .venv/bin/activate
```
Aktywowanie środowiska języka Python oznacza, że po uruchomieniu python lub pip w wierszu polecenia używasz interpretera języka Python zawartego w folderze .venv aplikacji. Możesz użyć deactivate polecenia , aby zamknąć środowisko wirtualne języka Python i później ponownie aktywować je w razie potrzeby.

Wskazówka

Zalecamy utworzenie i aktywowanie nowego środowiska języka Python w celu zainstalowania pakietów potrzebnych na potrzeby tego samouczka. Nie instaluj pakietów w globalnej instalacji języka Python. Zawsze należy używać środowiska wirtualnego lub conda podczas instalowania pakietów języka Python. W przeciwnym razie możesz przerwać globalną instalację języka Python.
Zainstaluj bibliotekę klienta języka Python openAI za pomocą następujących elementów:
```
pip install openai[realtime]
```
Uwaga / Notatka

Ta biblioteka jest utrzymywana przez OpenAI. Zapoznaj się z historyją wydań, aby śledzić najnowsze aktualizacje biblioteki.
Aby uzyskać zalecane uwierzytelnianie bez klucza za pomocą identyfikatora Entra firmy Microsoft, zainstaluj pakiet za azure-identity pomocą polecenia:
```
pip install azure-identity
```

Pobieranie informacji o zasobie

Aby uwierzytelnić aplikację przy użyciu zasobu usługi Azure OpenAI, musisz pobrać następujące informacje:

Microsoft Entra ID
Klucz interfejsu API

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.

Dowiedz się więcej na temat uwierzytelniania bez klucza i ustawiania zmiennych środowiskowych.

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_API_KEY`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal. Możesz użyć wartości `KEY1` lub `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.

Dowiedz się więcej na temat znajdowania kluczy interfejsu API i ustawiania zmiennych środowiskowych.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Ostrzeżenie

Aby użyć zalecanego uwierzytelniania bez klucza z zestawem SDK, upewnij się, że zmienna AZURE_OPENAI_API_KEY środowiskowa nie jest ustawiona.

Tekst w dźwięku wychodzący

Microsoft Entra ID
Klucz interfejsu API

text-in-audio-out.py Utwórz plik przy użyciu następującego kodu:

import os
import base64
import asyncio
from openai import AsyncOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

async def main() -> None:
    """
    When prompted for user input, type a message and hit enter to send it to the model.
    Enter "q" to quit the conversation.
    """

    credential = DefaultAzureCredential()
    token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
    token = token_provider()

    # The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    # environment variable.
    # You can find it in the Microsoft Foundry portal in the Overview page of your Azure OpenAI resource.
    # Example: https://{your-resource}.openai.azure.com
    endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]

    # The deployment name of the model you want to use is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    # environment variable.
    # You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    # Example: gpt-realtime
    deployment_name = os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"]

    base_url = endpoint.replace("https://", "wss://").rstrip("/") + "/openai/v1"

    # The APIs are compatible with the OpenAI client library.
    # You can use the OpenAI client library to access the Azure OpenAI APIs.
    # Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    client = AsyncOpenAI(
        websocket_base_url=base_url,
        api_key=token
    )
    async with client.realtime.connect(
        model=deployment_name,
    ) as connection:
        # after the connection is created, configure the session.
        await connection.session.update(session={
            "type": "realtime",
            "instructions": "You are a helpful assistant. You respond by voice and text.",
            "output_modalities": ["audio"],
            "audio": {
                "input": {
                    "transcription": {
                        "model": "whisper-1",
                    },
                    "format": {
                        "type": "audio/pcm",
                        "rate": 24000,
                    },
                    "turn_detection": {
                        "type": "server_vad",
                        "threshold": 0.5,
                        "prefix_padding_ms": 300,
                        "silence_duration_ms": 200,
                        "create_response": True,
                    }
                },
                "output": {
                    "voice": "alloy",
                    "format": {
                        "type": "audio/pcm",
                        "rate": 24000,
                    }
                }
            }
        })

        # After the session is configured, data can be sent to the session.
        while True:
            user_input = input("Enter a message: ")
            if user_input == "q":
                print("Stopping the conversation.")
                break

            await connection.conversation.item.create(
                item={
                    "type": "message",
                    "role": "user",
                    "content": [{"type": "input_text", "text": user_input}],
                }
            )
            await connection.response.create()
            async for event in connection:
                if event.type == "response.output_text.delta":
                    print(event.delta, flush=True, end="")
                elif event.type == "session.created":
                    print(f"Session ID: {event.session.id}")
                elif event.type == "response.output_audio.delta":
                    audio_data = base64.b64decode(event.delta)
                    print(f"Received {len(audio_data)} bytes of audio data.")
                elif event.type == "response.output_audio_transcript.delta":
                    print(f"Received text delta: {event.delta}")
                elif event.type == "response.output_text.done":
                    print()
                elif event.type == "error":
                    print("Received an error event.")
                    print(f"Error code: {event.error.code}")
                    print(f"Error Event ID: {event.error.event_id}")
                    print(f"Error message: {event.error.message}")
                elif event.type == "response.done":
                    break

    print("Conversation ended.")
    credential.close()

asyncio.run(main())

Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom plik języka Python.
```
python text-in-audio-out.py
```
Po wyświetleniu monitu o podanie danych wejściowych użytkownika wpisz komunikat i naciśnij Enter, aby wysłać go do modelu. Wprowadź "q", aby zakończyć konwersację.

text-in-audio-out.py Utwórz plik przy użyciu następującego kodu:

import os
import base64
import asyncio
from openai import AsyncOpenAI

async def main() -> None:
    """
    When prompted for user input, type a message and hit enter to send it to the model.
    Enter "q" to quit the conversation.
    """

    # The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    # environment variable.
    # You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    # Example: https://{your-resource}.openai.azure.com
    endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]
    base_url = endpoint.replace("https://", "wss://").rstrip("/") + "/openai/v1"

    # The deployment name of the model you want to use is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    # environment variable.
    # You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    # Example: gpt-realtime
    deployment_name = os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"]

    # API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
    # environment variable.
    # You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    token=os.environ["AZURE_OPENAI_API_KEY"]

    # The APIs are compatible with the OpenAI client library.
    # You can use the OpenAI client library to access the Azure OpenAI APIs.
    # Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    client = AsyncOpenAI(
        websocket_base_url=base_url,
        api_key=token
    )
    async with client.realtime.connect(
        model=deployment_name,
    ) as connection:
        # after the connection is created, configure the session.
        await connection.session.update(session={
            "type": "realtime",
            "instructions": "You are a helpful assistant. You respond by voice and text.",
            "output_modalities": ["audio"],
            "audio": {
                "input": {
                    "transcription": {
                        "model": "whisper-1",
                    },
                    "format": {
                        "type": "audio/pcm",
                        "rate": 24000,
                    },
                    "turn_detection": {
                        "type": "server_vad",
                        "threshold": 0.5,
                        "prefix_padding_ms": 300,
                        "silence_duration_ms": 200,
                        "create_response": True,
                    }
                },
                "output": {
                    "voice": "alloy",
                    "format": {
                        "type": "audio/pcm",
                        "rate": 24000,
                    }
                }
            }
        })

        # After the session is configured, data can be sent to the session.
        while True:
            user_input = input("Enter a message: ")
            if user_input == "q":
                print("Stopping the conversation.")
                break

            await connection.conversation.item.create(
                item={
                    "type": "message",
                    "role": "user",
                    "content": [{"type": "input_text", "text": user_input}],
                }
            )
            await connection.response.create()
            async for event in connection:
                if event.type == "response.output_text.delta":
                    print(event.delta, flush=True, end="")
                elif event.type == "session.created":
                    print(f"Session ID: {event.session.id}")
                elif event.type == "response.output_audio.delta":
                    audio_data = base64.b64decode(event.delta)
                    print(f"Received {len(audio_data)} bytes of audio data.")
                elif event.type == "response.output_audio_transcript.delta":
                    print(f"Received text delta: {event.delta}")
                elif event.type == "response.output_text.done":
                    print()
                elif event.type == "error":
                    print("Received an error event.")
                    print(f"Error code: {event.error.code}")
                    print(f"Error Event ID: {event.error.event_id}")
                    print(f"Error message: {event.error.message}")
                elif event.type == "response.done":
                    break

    print("Conversation ended.")

asyncio.run(main())

Uruchom plik języka Python.
```
python text-in-audio-out.py
```
Po wyświetleniu monitu o podanie danych wejściowych użytkownika wpisz komunikat i naciśnij Enter, aby wysłać go do modelu. Wprowadź "q", aby zakończyć konwersację.

Poczekaj chwilę, aby uzyskać odpowiedź.

Wynik

Skrypt pobiera odpowiedź z modelu i wyświetla odebrane dane transkrypcji i audio.

Dane wyjściowe wyglądają podobnie do następujących:

Enter a message: How are you today?
Session ID: sess_CgAuonaqdlSNNDTdqBagI
Received text delta: I'm
Received text delta:  doing
Received text delta:  well
Received text delta: ,
Received 4800 bytes of audio data.
Received 7200 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  thank
Received text delta:  you
Received text delta:  for
Received text delta:  asking
Received text delta: !
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  How
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received text delta:  about
Received text delta:  you
Received text delta: —
Received text delta: how
Received text delta:  are
Received text delta:  you
Received text delta:  feeling
Received text delta:  today
Received text delta: ?
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 12000 bytes of audio data.
Received 24000 bytes of audio data.
Enter a message: q
Stopping the conversation.
Conversation ended.

Wymagania wstępne

Subskrypcja platformy Azure - Utwórz ją za darmo
obsługa Node.js LTS lub ESM.
Język TypeScript zainstalowany globalnie.
Zasób usługi Azure OpenAI utworzony w jednym z obsługiwanych regionów. Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.
Następnie należy wdrożyć gpt-realtime model przy użyciu zasobu usługi Azure OpenAI. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu i wdrażanie modelu za pomocą usługi Azure OpenAI.

Wymagania wstępne dotyczące Microsoft Entra ID

W przypadku zalecanego uwierzytelniania bez klucza za pomocą identyfikatora Entra firmy Microsoft należy wykonać następujące czynności:

Zainstaluj Azure CLI używane do uwierzytelniania bezkluczowego za pomocą Microsoft Entra ID.
Cognitive Services OpenAI User Przypisz rolę do konta użytkownika. Role można przypisać w portalu Azure w sekcji Kontrola dostępu (IAM)>Dodawanie przypisania roli.

Wdrażanie modelu na potrzeby dźwięku w czasie rzeczywistym

Aby wdrożyć gpt-realtime model w portalu Microsoft Foundry:

Przejdź do portalu Foundry i utwórz lub wybierz projekt.
Wybierz wdrożenia modelu:
1. W polu Zasób usługi Azure OpenAI wybierz pozycję Wdrożenia w sekcji Zasoby udostępnione w okienku po lewej stronie.
2. W zasobie Foundry wybierz Modele i punkty końcowe z sekcji Moje zasoby po lewej stronie.
Wybierz pozycję + Wdróż model>podstawowy, aby otworzyć okno wdrażania.
Wyszukaj i wybierz gpt-realtime model, a następnie wybierz pozycję Potwierdź.
Przejrzyj szczegóły wdrożenia i wybierz pozycję Wdróż.
Postępuj zgodnie z instrukcjami kreatora, aby zakończyć wdrażanie modelu.

Teraz, gdy masz wdrożenie gpt-realtime modelu, możesz korzystać z niego w portalu Foundry, w placu zabaw Audio lub API w czasie rzeczywistym.

Ustawienia

Utwórz nowy folder realtime-audio-quickstart-ts i przejdź do folderu Szybki start za pomocą następującego polecenia:
```
mkdir realtime-audio-quickstart-ts && cd realtime-audio-quickstart-ts
```
Utwórz element package.json za pomocą następującego polecenia:
```
npm init -y
```
Zaktualizuj package.json do ECMAScript za pomocą następującego polecenia:
```
npm pkg set type=module
```
Zainstaluj bibliotekę klienta openAI dla języka JavaScript za pomocą następujących narzędzi:
```
npm install openai
```
Zainstaluj pakiety zależne używane przez bibliotekę klienta OpenAI dla języka JavaScript za pomocą następujących narzędzi:
```
npm install ws
```
Aby uzyskać zalecane uwierzytelnianie bez klucza za pomocą identyfikatora Entra firmy Microsoft, zainstaluj pakiet za @azure/identity pomocą polecenia:
```
npm install @azure/identity
```

Pobieranie informacji o zasobie

Aby uwierzytelnić aplikację przy użyciu zasobu usługi Azure OpenAI, musisz pobrać następujące informacje:

Microsoft Entra ID
Klucz interfejsu API

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.

Dowiedz się więcej na temat uwierzytelniania bez klucza i ustawiania zmiennych środowiskowych.

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_API_KEY`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal. Możesz użyć wartości `KEY1` lub `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.

Dowiedz się więcej na temat znajdowania kluczy interfejsu API i ustawiania zmiennych środowiskowych.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Ostrzeżenie

Aby użyć zalecanego uwierzytelniania bez klucza z zestawem SDK, upewnij się, że zmienna AZURE_OPENAI_API_KEY środowiskowa nie jest ustawiona.

Tekst w dźwięku wychodzący

Microsoft Entra ID
Klucz interfejsu API

index.ts Utwórz plik przy użyciu następującego kodu:

import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';
import { OpenAIRealtimeError } from 'openai/realtime/internal-base';
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import { RealtimeSessionCreateRequest } from 'openai/resources/realtime/realtime';

let isCreated = false;
let isConfigured = false;
let responseDone = false;

// Set this to false, if you want to continue receiving events after an error is received.
const throwOnError = true;

async function main(): Promise<void> {
    // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    // environment variable or replace the default value below.
    // You can find it in the Microsoft Foundry portal in the Overview page of your Azure OpenAI resource.
    // Example: https://{your-resource}.openai.azure.com
    const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
    const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';

    // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    // Example: gpt-realtime
    const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';

    // Keyless authentication
    const credential = new DefaultAzureCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const token = await azureADTokenProvider();

    // The APIs are compatible with the OpenAI client library.
    // You can use the OpenAI client library to access the Azure OpenAI APIs.
    // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    const openAIClient = new OpenAI({
        baseURL: baseUrl,
        apiKey: token,
    });
    const realtimeClient = await OpenAIRealtimeWS.create(openAIClient, { model: deploymentName });

    realtimeClient.on('error', (receivedError) => receiveError(receivedError));
    realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));

    console.log('Waiting for events...');
    while (!isCreated) {
        console.log('Waiting for session.created event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is created, configure it to enable audio input and output.
    const sessionConfig: RealtimeSessionCreateRequest = {
        'type': 'realtime',
        'instructions': 'You are a helpful assistant. You respond by voice and text.',
        'output_modalities': ['audio'],
        'audio': {
            'input': {
                'transcription': {
                    'model': 'whisper-1'
                },
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                },
                'turn_detection': {
                    'type': 'server_vad',
                    'threshold': 0.5,
                    'prefix_padding_ms': 300,
                    'silence_duration_ms': 200,
                    'create_response': true
                }
            },
            'output': {
                'voice': 'alloy',
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                }
            }
        }
    };

    realtimeClient.send({ 'type': 'session.update', 'session': sessionConfig });

    while (!isConfigured) {
        console.log('Waiting for session.updated event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is configured, data can be sent to the session.
    realtimeClient.send({
        'type': 'conversation.item.create',
        'item': {
            'type': 'message',
            'role': 'user',
            'content': [{ type: 'input_text', text: 'Please assist the user.' }]
        }
    });

    realtimeClient.send({ type: 'response.create' });

    // While waiting for the session to finish, the events can be handled in the event handlers.
    // In this example, we just wait for the first response.done event. 
    while (!responseDone) {
        console.log('Waiting for response.done event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    console.log('The sample completed successfully.');
    realtimeClient.close();
}

function receiveError(errorEvent: OpenAIRealtimeError): void {
    if (errorEvent instanceof OpenAIRealtimeError) {
        console.error('Received an error event.');
        console.error(`Message: ${errorEvent.message}`);
        console.error(`Stack: ${errorEvent.stack}`); errorEvent
    }

    if (throwOnError) {
        throw errorEvent;
    }
}

function receiveEvent(event: any): void {
    console.log(`Received an event: ${event.type}`);

    switch (event.type) {
        case 'session.created':
            console.log(`Session ID: ${event.session.id}`);
            isCreated = true;
            break;
        case 'session.updated':
            console.log(`Session ID: ${event.session.id}`);
            isConfigured = true;
            break;
        case 'response.output_audio_transcript.delta':
            console.log(`Transcript delta: ${event.delta}`);
            break;
        case 'response.output_audio.delta':
            let audioBuffer = Buffer.from(event.delta, 'base64');
            console.log(`Audio delta length: ${audioBuffer.length} bytes`);
            break;
        case 'response.done':
            console.log(`Response ID: ${event.response.id}`);
            console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
            responseDone = true;
            break;
        default:
            console.warn(`Unhandled event type: ${event.type}`);
    }
}

main().catch((err) => {
    console.error("The sample encountered an error:", err);
});

export { main };

Utwórz plik tsconfig.json do transpilacji kodu TypeScript i skopiuj następujący kod dla ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Instalowanie definicji typów dla środowiska Node
```
npm i --save-dev @types/node
```
Transpiluj z języka TypeScript do języka JavaScript.
```
tsc
```
Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom kod za pomocą następującego polecenia:
```
node index.js
```

index.ts Utwórz plik przy użyciu następującego kodu:

import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';
import { OpenAIRealtimeError } from 'openai/realtime/internal-base';
import { RealtimeSessionCreateRequest } from 'openai/resources/realtime/realtime';

let isCreated = false;
let isConfigured = false;
let responseDone = false;

// Set this to false, if you want to continue receiving events after an error is received.
const throwOnError = true;

async function main(): Promise<void> {
    // The endpoint of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_ENDPOINT
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    // Example: https://{your-resource}.openai.azure.com
    const endpoint = process.env.AZURE_OPENAI_ENDPOINT || 'AZURE_OPENAI_ENDPOINT';
    const baseUrl = endpoint.replace(/\/$/, "") + '/openai/v1';

    // The deployment name of your Azure OpenAI model is required. You can set it in the AZURE_OPENAI_DEPLOYMENT_NAME
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the "Models + endpoints" page of your Azure OpenAI resource.
    // Example: gpt-realtime
    const deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || 'gpt-realtime';

    // API Key of your Azure OpenAI resource is required. You can set it in the AZURE_OPENAI_API_KEY
    // environment variable or replace the default value below.
    // You can find it in the Foundry portal in the Overview page of your Azure OpenAI resource.
    const token = process.env.AZURE_OPENAI_API_KEY || '<Your API Key>';

    // The APIs are compatible with the OpenAI client library.
    // You can use the OpenAI client library to access the Azure OpenAI APIs.
    // Make sure to set the baseURL and apiKey to use the Azure OpenAI endpoint and token.
    const openAIClient = new OpenAI({
        baseURL: baseUrl,
        apiKey: token,
    });

    // Due to the current SDK limitation we need to explicitly
    // pass API key as Header
    const realtimeClient = await OpenAIRealtimeWS.create(
        openAIClient, {
        model: deploymentName,
        options: {
            headers: {
                "api-key": token
            }
        }
    });

    realtimeClient.on('error', (receivedError) => receiveError(receivedError));
    realtimeClient.on('session.created', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('session.updated', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.output_audio_transcript.delta', (receivedEvent) => receiveEvent(receivedEvent));
    realtimeClient.on('response.done', (receivedEvent) => receiveEvent(receivedEvent));

    console.log('Waiting for events...');
    while (!isCreated) {
        console.log('Waiting for session.created event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is created, configure it to enable audio input and output.
    const sessionConfig: RealtimeSessionCreateRequest = {
        'type': 'realtime',
        'instructions': 'You are a helpful assistant. You respond by voice and text.',
        'output_modalities': ['audio'],
        'audio': {
            'input': {
                'transcription': {
                    'model': 'whisper-1'
                },
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                },
                'turn_detection': {
                    'type': 'server_vad',
                    'threshold': 0.5,
                    'prefix_padding_ms': 300,
                    'silence_duration_ms': 200,
                    'create_response': true
                }
            },
            'output': {
                'voice': 'alloy',
                'format': {
                    'type': 'audio/pcm',
                    'rate': 24000,
                }
            }
        }
    };

    realtimeClient.send({
        'type': 'session.update',
        'session': sessionConfig
    });
    while (!isConfigured) {
        console.log('Waiting for session.updated event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    // After the session is configured, data can be sent to the session.    
    realtimeClient.send({
        'type': 'conversation.item.create',
        'item': {
            'type': 'message',
            'role': 'user',
            'content': [{
                type: 'input_text',
                text: 'Please assist the user.'
            }
            ]
        }
    });

    realtimeClient.send({
        type: 'response.create'
    });

    // While waiting for the session to finish, the events can be handled in the event handlers.
    // In this example, we just wait for the first response.done event.
    while (!responseDone) {
        console.log('Waiting for response.done event...');
        await new Promise((resolve) => setTimeout(resolve, 100));
    }

    console.log('The sample completed successfully.');
    realtimeClient.close();
}

function receiveError(errorEvent: OpenAIRealtimeError): void {
    if (errorEvent instanceof OpenAIRealtimeError) {
        console.error('Received an error event.');
        console.error(`Message: ${errorEvent.message}`);
        console.error(`Stack: ${errorEvent.stack}`);
        errorEvent
    }

    if (throwOnError) {
        throw errorEvent;
    }
}

function receiveEvent(event: any): void {
    console.log(`Received an event: ${event.type}`);

    switch (event.type) {
        case 'session.created':
            console.log(`Session ID: ${event.session.id}`);
            isCreated = true;
            break;
        case 'session.updated':
            console.log(`Session ID: ${event.session.id}`);
            isConfigured = true;
            break;
        case 'response.output_audio_transcript.delta':
            console.log(`Transcript delta: ${event.delta}`);
            break;
        case 'response.output_audio.delta':
            let audioBuffer = Buffer.from(event.delta, 'base64');
            console.log(`Audio delta length: ${audioBuffer.length} bytes`);
            break;
        case 'response.done':
            console.log(`Response ID: ${event.response.id}`);
            console.log(`The final response is: ${event.response.output[0].content[0].transcript}`);
            responseDone = true;
            break;
        default:
            console.warn(`Unhandled event type: ${event.type}`);
    }
}

main().catch((err) => {
    console.error("The sample encountered an error:", err);
});

export {
    main
};

Utwórz plik tsconfig.json do transpilacji kodu TypeScript i skopiuj następujący kod dla ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Instalowanie definicji typów dla środowiska Node
```
npm i --save-dev @types/node
```
Transpiluj z języka TypeScript do języka JavaScript.
```
tsc
```
Uruchom kod za pomocą następującego polecenia:
```
node index.js
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Wynik

Skrypt pobiera odpowiedź z modelu i wyświetla odebrane dane transkrypcji i audio.

Dane wyjściowe będą wyglądać podobnie do następujących:

Waiting for events...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Waiting for session.created event...
Received an event: session.created
Session ID: sess_CWQkREiv3jlU3gk48bm0a
Waiting for session.updated event...
Waiting for session.updated event...
Received an event: session.updated
Session ID: sess_CWQkREiv3jlU3gk48bm0a
Waiting for response.done event...
Waiting for response.done event...
Waiting for response.done event...
Waiting for response.done event...
Waiting for response.done event...
Received an event: response.output_audio_transcript.delta
Transcript delta: Sure
Received an event: response.output_audio_transcript.delta
Transcript delta: ,
Received an event: response.output_audio_transcript.delta
Transcript delta:  I'm
Received an event: response.output_audio_transcript.delta
Transcript delta:  here
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 4800 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 7200 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  to
Received an event: response.output_audio_transcript.delta
Transcript delta:  help
Received an event: response.output_audio_transcript.delta
Transcript delta: .
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  What
Received an event: response.output_audio_transcript.delta
Transcript delta:  would
Received an event: response.output_audio_transcript.delta
Transcript delta:  you
Received an event: response.output_audio_transcript.delta
Transcript delta:  like
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio_transcript.delta
Transcript delta:  to
Received an event: response.output_audio_transcript.delta
Transcript delta:  do
Received an event: response.output_audio_transcript.delta
Transcript delta:  or
Received an event: response.output_audio_transcript.delta
Transcript delta:  know
Received an event: response.output_audio_transcript.delta
Transcript delta:  about
Received an event: response.output_audio_transcript.delta
Transcript delta: ?
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Waiting for response.done event...
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 12000 bytes
Received an event: response.output_audio.delta
Audio delta length: 24000 bytes
Received an event: response.done
Response ID: resp_CWQkRBrCcCjtHgIEapA92
The final response is: Sure, I'm here to help. What would you like to do or know about?
The sample completed successfully.

Wdrażanie modelu na potrzeby dźwięku w czasie rzeczywistym

Aby wdrożyć gpt-realtime model w portalu Microsoft Foundry:

Przejdź do portalu Foundry i utwórz lub wybierz projekt.
Wybierz wdrożenia modelu:
1. W polu Zasób usługi Azure OpenAI wybierz pozycję Wdrożenia w sekcji Zasoby udostępnione w okienku po lewej stronie.
2. W zasobie Foundry wybierz Modele i punkty końcowe z sekcji Moje zasoby po lewej stronie.
Wybierz pozycję + Wdróż model>podstawowy, aby otworzyć okno wdrażania.
Wyszukaj i wybierz gpt-realtime model, a następnie wybierz pozycję Potwierdź.
Przejrzyj szczegóły wdrożenia i wybierz pozycję Wdróż.
Postępuj zgodnie z instrukcjami kreatora, aby zakończyć wdrażanie modelu.

Teraz, gdy masz wdrożenie gpt-realtime modelu, możesz korzystać z niego w portalu Foundry, w placu zabaw Audio lub API w czasie rzeczywistym.

Używanie dźwięku GPT w czasie rzeczywistym

Aby porozmawiać z wdrożonym gpt-realtime modelem na placu zabaw audio w czasie rzeczywistym firmy Microsoft Foundry, wykonaj następujące kroki:

Przejdź do portalu Foundry i wybierz projekt, który ma wdrożony gpt-realtime model.
Wybierz pozycję Place zabaw w okienku po lewej stronie.
Wybierz Plac zabaw audio>Wypróbuj plac zabaw audio.

Uwaga / Notatka

Plac zabaw czatu nie obsługuje gpt-realtime modelu. Użyj warsztatu audio zgodnie z opisem w tej sekcji.
Wybierz wdrożony gpt-realtime model z listy rozwijanej Wdrażanie .
Opcjonalnie możesz edytować zawartość w polu tekstowym Nadaj modelowi instrukcje i kontekst . Przekaż instrukcje dotyczące sposobu działania modelu i dowolnego kontekstu, do którego powinien się odwoływać podczas generowania odpowiedzi. Możesz opisać osobowość asystenta, określić na jakie pytania powinien lub nie powinien odpowiadać i określić, w jaki sposób ma formatować odpowiedzi.
Opcjonalnie zmień ustawienia, takie jak próg, dopełnienie prefiksu i czas trwania ciszy.
Wybierz pozycję Rozpocznij nasłuchiwanie , aby rozpocząć sesję. Możesz mówić do mikrofonu, aby rozpocząć czat.
Możesz przerwać czat w dowolnym momencie, mówiąc. Możesz zakończyć czat, wybierając przycisk Zatrzymaj nasłuchiwanie .

Dowiedz się więcej o sposobie korzystania z interfejsu API czasu rzeczywistego
Zobacz dokumentację interfejsu API czasu rzeczywistego
Dowiedz się więcej o przydziałach i limitach usługi Azure OpenAI
Dowiedz się więcej o obsłudze języka i głosu dla usługi Mowa

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-11-25

Udostępnij przez

Interfejs API GPT Realtime dla mowy i dźwięku

Obsługiwane modele

Obsługa interfejsu API

Wymagania wstępne

Wymagania wstępne dotyczące Microsoft Entra ID

Wdrażanie modelu na potrzeby dźwięku w czasie rzeczywistym

Ustawienia

Pobieranie informacji o zasobie

Tekst w dźwięku wychodzący

Wynik

Wymagania wstępne

Wymagania wstępne dotyczące Microsoft Entra ID

Wdrażanie modelu na potrzeby dźwięku w czasie rzeczywistym

Ustawienia

Pobieranie informacji o zasobie

Tekst w dźwięku wychodzący

Wynik

Wymagania wstępne

Wymagania wstępne dotyczące Microsoft Entra ID

Wdrażanie modelu na potrzeby dźwięku w czasie rzeczywistym

Ustawienia

Pobieranie informacji o zasobie

Tekst w dźwięku wychodzący

Wynik

Wdrażanie modelu na potrzeby dźwięku w czasie rzeczywistym

Używanie dźwięku GPT w czasie rzeczywistym

Treści powiązane

Sprzężenie zwrotne

Dodatkowe źródła