GPT Realtime-API für Sprache und Audio

Hinweis

Dieses Dokument bezieht sich auf das Microsoft Foundry(klassische) Portal.

🔄 Wechseln Sie zur Microsoft Foundry-Dokumentation (neu), wenn Sie das neue Portal verwenden.

Hinweis

Dieses Dokument bezieht sich auf das Microsoft Foundry (neue) Portal.

Die GPT Realtime-API von Azure OpenAI für Sprache und Audio ist Teil der GPT-4o-Modellfamilie, die latenzarme Unterhaltungsinteraktionen mit Spracheingabe und Sprachausgabe unterstützt.

Sie können die Realtime-API über WebRTC oder WebSocket verwenden, um Audioeingaben an das Modell zu senden und Audioantworten in Echtzeit zu empfangen.

Befolgen Sie die Anweisungen in diesem Artikel, um mit der Realtime-API über WebSockets zu beginnen. Verwenden Sie die Realtime-API über WebSockets in Server-zu-Server-Szenarien, in denen eine geringe Latenz keine Anforderung ist.

Tipp

In den meisten Fällen empfehlen wir die Verwendung der Realtime-API über WebRTC für echtzeitbasiertes Audiostreaming in clientseitigen Anwendungen wie einer Webanwendung oder einer mobilen App. WebRTC ist für Audiostreaming mit geringer Latenz und in Echtzeit konzipiert und die beste Wahl für die meisten Anwendungsfälle.

Unterstützte Modelle

Die GPT-Echtzeitmodelle sind für globale Bereitstellungen verfügbar.

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

Weitere Informationen finden Sie in der Dokumentation zu Modellen und Versionen.

API-Unterstützung

Die Unterstützung für die Echtzeit-API wurde erstmals in der API-Version 2024-10-01-preview (eingestellt) hinzugefügt. Verwenden Sie die Version 2025-08-28 , um auf die neuesten Realtime-API-Features zuzugreifen. Es wird empfohlen, nach Möglichkeit die allgemein verfügbare API-Version (ohne Suffix "-preview") auszuwählen.

Vorsicht

Sie müssen unterschiedliche Endpunktformate für Preview- und Allgemein verfügbare (GA)-Modelle verwenden. Alle Beispiele in diesem Artikel verwenden GA-Modelle und das GA-Endpunktformat und verwenden keinen api-version Parameter, der nur für das Vorschauendpunktformat erforderlich ist. Ausführliche Informationen zum Endpunktformat finden Sie in diesem Artikel.

Voraussetzungen

Ein Azure-Abonnement – Kostenlos erstellen
Node.js LTS- oder ESM-Unterstützung.
Eine Azure OpenAI-Ressource, die in einer der unterstützten Regionen erstellt wurde. Weitere Informationen zur Verfügbarkeit in Regionen finden Sie in der Dokumentation zu Modellen und Versionen.
Anschließend müssen Sie ein gpt-realtime-Modell mit Ihrer Azure OpenAI-Ressource bereitstellen. Weitere Informationen finden Sie unter Erstellen einer Ressource und Bereitstellen eines Modells mit Azure OpenAI.

Voraussetzungen für Microsoft Entra ID

Für die empfohlene schlüssellose Authentifizierung mit Microsoft Entra ID müssen Sie:

Installieren Sie die Azure CLI , die für die schlüssellose Authentifizierung mit der Microsoft Entra-ID verwendet wird.
Weisen Sie Ihrem Benutzerkonto die Cognitive Services OpenAI User-Rolle zu. Sie können Rollen im Azure-Portal unter Zugriffssteuerung (IAM)>Rollenzuweisung hinzufügen zuweisen.

Bereitstellen eines Modells für Echtzeitaudio

So stellen Sie das gpt-realtime Modell im Microsoft Foundry-Portal bereit:

Wechseln Sie zum Foundry-Portal , und erstellen oder wählen Sie Ihr Projekt aus.
Wählen Sie Ihre Modellbereitstellungen aus:
1. Wählen Sie für Azure OpenAI-Ressource im linken Bereich " Bereitstellungen " im Abschnitt "Freigegebene Ressourcen " aus.
2. Wählen Sie für die Ressource "Foundry" die Option "Modelle + Endpunkte " unter "Meine Ressourcen " im linken Bereich aus.
Wählen Sie +Modell bereitstellen>Basismodell bereitstellen aus, um das Bereitstellungsfenster zu öffnen.
Suchen Sie nach dem Modell gpt-realtime, wählen Sie es aus, und wählen Sie dann Bestätigen aus.
Überprüfen Sie die Bereitstellungsdetails, und wählen Sie "Bereitstellen" aus.
Durchlaufen Sie den Assistenten, um die Bereitstellung des Modells abzuschließen.

Nachdem Sie nun über eine Bereitstellung des gpt-realtime Modells verfügen, können Sie mit dem Modell im Foundry-Portal Audio Playground oder Realtime API interagieren.

Einrichten

Erstellen Sie einen neuen Ordner realtime-audio-quickstart-js , und wechseln Sie mit dem folgenden Befehl zum Schnellstartordner:
```
mkdir realtime-audio-quickstart-js && cd realtime-audio-quickstart-js
```
Erstellen Sie package.json mit dem folgenden Befehl:
```
npm init -y
```
Aktualisieren Sie type zu module in package.json mit dem folgenden Befehl.
```
npm pkg set type=module
```
Installieren Sie die OpenAI-Clientbibliothek für JavaScript mit:
```
npm install openai
```
Installieren Sie die abhängigen Pakete, die von der OpenAI-Clientbibliothek für JavaScript verwendet werden, mit:
```
npm install ws
```
Installieren Sie für die empfohlene schlüssellose Authentifizierung mit Microsoft Entra ID das @azure/identity-Paket mit:
```
npm install @azure/identity
```

Abrufen von Ressourceninformationen

Sie müssen die folgenden Informationen abrufen, um Ihre Anwendung bei Ihrer Azure OpenAI-Ressource zu authentifizieren:

Microsoft Entra-ID
API-Schlüssel

Variablenname	Wert
`AZURE_OPENAI_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Dieser Wert entspricht dem benutzerdefinierten Namen, den Sie bei der Bereitstellung eines Modells ausgewählt haben. Diesen Wert finden Sie unter Ressourcenverwaltung>Modellbereitstellungen im Azure-Portal.

Erfahren Sie mehr über schlüssellose Authentifizierung und das Festlegen von Umgebungsvariablen.

Variablenname	Wert
`AZURE_OPENAI_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen.
`AZURE_OPENAI_API_KEY`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Sie können `KEY1` oder `KEY2` verwenden.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Dieser Wert entspricht dem benutzerdefinierten Namen, den Sie bei der Bereitstellung eines Modells ausgewählt haben. Diesen Wert finden Sie unter Ressourcenverwaltung>Modellbereitstellungen im Azure-Portal.

Erfahren Sie mehr über das Ermitteln von API-Schlüsseln und das Festlegen von Umgebungsvariablen.

Von Bedeutung

Verwenden Sie API-Schlüssel mit Vorsicht. Fügen Sie den API-Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Wenn Sie einen API-Schlüssel verwenden, speichern Sie ihn sicher in Azure Key Vault. Weitere Informationen zur sicheren Verwendung von API-Schlüsseln in Ihren Apps finden Sie unter API-Schlüssel mit Azure Key Vault.

Weitere Informationen zur Sicherheit von KI-Diensten finden Sie unter Authentifizieren von Anforderungen an Azure AI-Dienste.

Vorsicht

Um die empfohlene schlüssellose Authentifizierung mit dem SDK zu verwenden, stellen Sie sicher, dass die Umgebungsvariable AZURE_OPENAI_API_KEY nicht festgelegt ist.

Erstellen Sie die Datei index.js mit dem folgenden Code:

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
};

Melden Sie sich mithilfe des folgenden Befehls bei Azure an:
```
az login
```
Führen Sie die JavaScript-Datei aus.
```
node index.js
```

Erstellen Sie die Datei index.js mit dem folgenden Code:

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
};

Führen Sie die JavaScript-Datei aus.
```
node index.js
```

Warten Sie einen Moment auf die Antwort.

Output

Das Skript ruft eine Antwort vom Modell ab und gibt die empfangenen Transkript- und Audiodaten aus.

Die Ausgabe sieht in etwa wie folgt aus:

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.

Voraussetzungen

Ein Azure-Abonnement. Erstellen Sie ein kostenloses Konto.
Python 3.8 oder eine höhere Version Es wird empfohlen, Python 3.10 oder höher zu verwenden, aber mindestens Python 3.8 ist erforderlich. Wenn Sie keine geeignete Version von Python installiert haben, können Sie die Anweisungen im VS Code Python-Lernprogramm befolgen, um Python am einfachsten auf Ihrem Betriebssystem zu installieren.
Eine Azure OpenAI-Ressource, die in einer der unterstützten Regionen erstellt wurde. Weitere Informationen zur Verfügbarkeit in Regionen finden Sie in der Dokumentation zu Modellen und Versionen.
Anschließend müssen Sie ein gpt-realtime, gpt-realtime-mini oder gpt-realtime-mini-2025-12-15 Modell mit Ihrer Azure OpenAI-Ressource bereitstellen. Weitere Informationen finden Sie unter Erstellen einer Ressource und Bereitstellen eines Modells mit Azure OpenAI.

Voraussetzungen für Microsoft Entra ID

Für die empfohlene schlüssellose Authentifizierung mit Microsoft Entra ID müssen Sie:

Installieren Sie die Azure CLI , die für die schlüssellose Authentifizierung mit der Microsoft Entra-ID verwendet wird.
Weisen Sie Ihrem Benutzerkonto die Cognitive Services OpenAI User-Rolle zu. Sie können Rollen im Azure-Portal unter Zugriffssteuerung (IAM)>Rollenzuweisung hinzufügen zuweisen.

Bereitstellen eines Modells für Echtzeitaudio

So stellen Sie das gpt-realtime Modell im Microsoft Foundry-Portal bereit:

Wechseln Sie zum Foundry-Portal , und erstellen oder wählen Sie Ihr Projekt aus.
Wählen Sie Ihre Modellbereitstellungen aus:
1. Wählen Sie für Azure OpenAI-Ressource im linken Bereich " Bereitstellungen " im Abschnitt "Freigegebene Ressourcen " aus.
2. Wählen Sie für die Ressource "Foundry" die Option "Modelle + Endpunkte " unter "Meine Ressourcen " im linken Bereich aus.
Wählen Sie +Modell bereitstellen>Basismodell bereitstellen aus, um das Bereitstellungsfenster zu öffnen.
Suchen Sie nach dem Modell gpt-realtime, wählen Sie es aus, und wählen Sie dann Bestätigen aus.
Überprüfen Sie die Bereitstellungsdetails, und wählen Sie "Bereitstellen" aus.
Durchlaufen Sie den Assistenten, um die Bereitstellung des Modells abzuschließen.

Nachdem Sie nun über eine Bereitstellung des gpt-realtime Modells verfügen, können Sie mit dem Modell im Foundry-Portal Audio Playground oder Realtime API interagieren.

Einrichten

Erstellen Sie einen neuen Ordner realtime-audio-quickstart-py , und wechseln Sie mit dem folgenden Befehl zum Schnellstartordner:
```
mkdir realtime-audio-quickstart-py && cd realtime-audio-quickstart-py
```
Erstellen einer virtuellen Umgebung Wenn Sie Python 3.10 oder höher bereits installiert haben, können Sie mit den folgenden Befehlen eine virtuelle Umgebung erstellen:
- Fenster
- 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
```
Wenn Sie die Python-Umgebung aktivieren, verwenden Sie beim Ausführen von python oder pip über die Befehlszeile den Python-Interpreter, der im Ordner .venv Ihrer Anwendung enthalten ist. Sie können den Befehl deactivate verwenden, um die virtuelle Python-Umgebung zu beenden, und sie später bei Bedarf reaktivieren.

Tipp

Es wird empfohlen, eine neue Python-Umgebung zu erstellen und zu aktivieren, um die Pakete zu installieren, die Sie für dieses Tutorial benötigen. Installieren Sie keine Pakete in Ihrer globalen Python-Installation. Sie sollten beim Installieren von Python-Paketen immer eine virtuelle oder Conda-Umgebung verwenden, andernfalls können Sie die globale Python-Installation beschädigen.
Installieren Sie die OpenAI Python-Clientbibliothek mit:
```
pip install openai[realtime]
```
Hinweis

Diese Bibliothek wird von OpenAI verwaltet. Lesen Sie den Versionsverlauf, um die neuesten Updates für die Bibliothek nachzuverfolgen.
Installieren Sie für die empfohlene schlüssellose Authentifizierung mit Microsoft Entra ID das azure-identity-Paket mit:
```
pip install azure-identity
```

Abrufen von Ressourceninformationen

Sie müssen die folgenden Informationen abrufen, um Ihre Anwendung bei Ihrer Azure OpenAI-Ressource zu authentifizieren:

Microsoft Entra-ID
API-Schlüssel

Variablenname	Wert
`AZURE_OPENAI_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Dieser Wert entspricht dem benutzerdefinierten Namen, den Sie bei der Bereitstellung eines Modells ausgewählt haben. Diesen Wert finden Sie unter Ressourcenverwaltung>Modellbereitstellungen im Azure-Portal.

Erfahren Sie mehr über schlüssellose Authentifizierung und das Festlegen von Umgebungsvariablen.

Variablenname	Wert
`AZURE_OPENAI_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen.
`AZURE_OPENAI_API_KEY`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Sie können `KEY1` oder `KEY2` verwenden.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Dieser Wert entspricht dem benutzerdefinierten Namen, den Sie bei der Bereitstellung eines Modells ausgewählt haben. Diesen Wert finden Sie unter Ressourcenverwaltung>Modellbereitstellungen im Azure-Portal.

Erfahren Sie mehr über das Ermitteln von API-Schlüsseln und das Festlegen von Umgebungsvariablen.

Von Bedeutung

Weitere Informationen zur Sicherheit von KI-Diensten finden Sie unter Authentifizieren von Anforderungen an Azure AI-Dienste.

Vorsicht

Um die empfohlene schlüssellose Authentifizierung mit dem SDK zu verwenden, stellen Sie sicher, dass die Umgebungsvariable AZURE_OPENAI_API_KEY nicht festgelegt ist.

Texteingabe, Audioausgabe

Microsoft Entra-ID
API-Schlüssel

Erstellen Sie die Datei text-in-audio-out.py mit dem folgenden Code:

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())

Melden Sie sich mithilfe des folgenden Befehls bei Azure an:
```
az login
```
Führen Sie die Python-Datei aus.
```
python text-in-audio-out.py
```
Wenn Sie zur Eingabe des Benutzers aufgefordert werden, geben Sie eine Nachricht ein, und drücken Sie die EINGABETASTE, um sie an das Modell zu senden. Geben Sie "q" ein, um die Unterhaltung zu beenden.

Erstellen Sie die Datei text-in-audio-out.py mit dem folgenden Code:

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())

Führen Sie die Python-Datei aus.
```
python text-in-audio-out.py
```
Wenn Sie zur Eingabe des Benutzers aufgefordert werden, geben Sie eine Nachricht ein, und drücken Sie die EINGABETASTE, um sie an das Modell zu senden. Geben Sie "q" ein, um die Unterhaltung zu beenden.

Warten Sie einen Moment auf die Antwort.

Output

Das Skript ruft eine Antwort vom Modell ab und gibt die empfangenen Transkript- und Audiodaten aus.

Die Ausgabe sieht in etwa wie folgt aus:

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.

Voraussetzungen

Ein Azure-Abonnement – Kostenlos erstellen
Node.js LTS- oder ESM-Unterstützung.
TypeScript ist global installiert.
Eine Azure OpenAI-Ressource, die in einer der unterstützten Regionen erstellt wurde. Weitere Informationen zur Verfügbarkeit in Regionen finden Sie in der Dokumentation zu Modellen und Versionen.
Anschließend müssen Sie ein gpt-realtime-Modell mit Ihrer Azure OpenAI-Ressource bereitstellen. Weitere Informationen finden Sie unter Erstellen einer Ressource und Bereitstellen eines Modells mit Azure OpenAI.

Voraussetzungen für Microsoft Entra ID

Für die empfohlene schlüssellose Authentifizierung mit Microsoft Entra ID müssen Sie:

Installieren Sie die Azure CLI , die für die schlüssellose Authentifizierung mit der Microsoft Entra-ID verwendet wird.
Weisen Sie Ihrem Benutzerkonto die Cognitive Services OpenAI User-Rolle zu. Sie können Rollen im Azure-Portal unter Zugriffssteuerung (IAM)>Rollenzuweisung hinzufügen zuweisen.

Bereitstellen eines Modells für Echtzeitaudio

So stellen Sie das gpt-realtime Modell im Microsoft Foundry-Portal bereit:

Wechseln Sie zum Foundry-Portal , und erstellen oder wählen Sie Ihr Projekt aus.
Wählen Sie Ihre Modellbereitstellungen aus:
1. Wählen Sie für Azure OpenAI-Ressource im linken Bereich " Bereitstellungen " im Abschnitt "Freigegebene Ressourcen " aus.
2. Wählen Sie für die Ressource "Foundry" die Option "Modelle + Endpunkte " unter "Meine Ressourcen " im linken Bereich aus.
Wählen Sie +Modell bereitstellen>Basismodell bereitstellen aus, um das Bereitstellungsfenster zu öffnen.
Suchen Sie nach dem Modell gpt-realtime, wählen Sie es aus, und wählen Sie dann Bestätigen aus.
Überprüfen Sie die Bereitstellungsdetails, und wählen Sie "Bereitstellen" aus.
Durchlaufen Sie den Assistenten, um die Bereitstellung des Modells abzuschließen.

Nachdem Sie nun über eine Bereitstellung des gpt-realtime Modells verfügen, können Sie mit dem Modell im Foundry-Portal Audio Playground oder Realtime API interagieren.

Einrichten

Erstellen Sie einen neuen Ordner realtime-audio-quickstart-ts , und wechseln Sie mit dem folgenden Befehl zum Schnellstartordner:
```
mkdir realtime-audio-quickstart-ts && cd realtime-audio-quickstart-ts
```
Erstellen Sie package.json mit dem folgenden Befehl:
```
npm init -y
```
Mit dem folgenden Befehl aktualisieren Sie package.json auf ECMAScript.
```
npm pkg set type=module
```
Installieren Sie die OpenAI-Clientbibliothek für JavaScript mit:
```
npm install openai
```
Installieren Sie die abhängigen Pakete, die von der OpenAI-Clientbibliothek für JavaScript verwendet werden, mit:
```
npm install ws
```
Installieren Sie für die empfohlene schlüssellose Authentifizierung mit Microsoft Entra ID das @azure/identity-Paket mit:
```
npm install @azure/identity
```

Abrufen von Ressourceninformationen

Sie müssen die folgenden Informationen abrufen, um Ihre Anwendung bei Ihrer Azure OpenAI-Ressource zu authentifizieren:

Microsoft Entra-ID
API-Schlüssel

Variablenname	Wert
`AZURE_OPENAI_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Dieser Wert entspricht dem benutzerdefinierten Namen, den Sie bei der Bereitstellung eines Modells ausgewählt haben. Diesen Wert finden Sie unter Ressourcenverwaltung>Modellbereitstellungen im Azure-Portal.

Erfahren Sie mehr über schlüssellose Authentifizierung und das Festlegen von Umgebungsvariablen.

Variablenname	Wert
`AZURE_OPENAI_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen.
`AZURE_OPENAI_API_KEY`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Sie können `KEY1` oder `KEY2` verwenden.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Dieser Wert entspricht dem benutzerdefinierten Namen, den Sie bei der Bereitstellung eines Modells ausgewählt haben. Diesen Wert finden Sie unter Ressourcenverwaltung>Modellbereitstellungen im Azure-Portal.

Erfahren Sie mehr über das Ermitteln von API-Schlüsseln und das Festlegen von Umgebungsvariablen.

Von Bedeutung

Weitere Informationen zur Sicherheit von KI-Diensten finden Sie unter Authentifizieren von Anforderungen an Azure AI-Dienste.

Vorsicht

Um die empfohlene schlüssellose Authentifizierung mit dem SDK zu verwenden, stellen Sie sicher, dass die Umgebungsvariable AZURE_OPENAI_API_KEY nicht festgelegt ist.

Texteingabe, Audioausgabe

Microsoft Entra-ID
API-Schlüssel

Erstellen Sie die Datei index.ts mit dem folgenden Code:

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 };

Erstellen Sie die Datei tsconfig.json, um den TypeScript-Code zu transpilieren, und kopieren Sie den folgenden Code für 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"]
}

Installationstypdefinitionen für Node
```
npm i --save-dev @types/node
```
Transpilieren Sie aus TypeScript nach JavaScript.
```
tsc
```
Melden Sie sich mithilfe des folgenden Befehls bei Azure an:
```
az login
```
Führen Sie den Code mithilfe des folgenden Befehls aus:
```
node index.js
```

Erstellen Sie die Datei index.ts mit dem folgenden Code:

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
};

Erstellen Sie die Datei tsconfig.json, um den TypeScript-Code zu transpilieren, und kopieren Sie den folgenden Code für 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"]
}

Installationstypdefinitionen für Node
```
npm i --save-dev @types/node
```
Transpilieren Sie aus TypeScript nach JavaScript.
```
tsc
```
Führen Sie den Code mithilfe des folgenden Befehls aus:
```
node index.js
```

Warten Sie einen Moment auf die Antwort.

Output

Das Skript ruft eine Antwort vom Modell ab und gibt die empfangenen Transkript- und Audiodaten aus.

Die Ausgabe sieht in etwa wie folgt aus:

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.

Bereitstellen eines Modells für Echtzeitaudio

So stellen Sie das gpt-realtime Modell im Microsoft Foundry-Portal bereit:

Wechseln Sie zum Foundry-Portal , und erstellen oder wählen Sie Ihr Projekt aus.
Wählen Sie Ihre Modellbereitstellungen aus:
1. Wählen Sie für Azure OpenAI-Ressource im linken Bereich " Bereitstellungen " im Abschnitt "Freigegebene Ressourcen " aus.
2. Wählen Sie für die Ressource "Foundry" die Option "Modelle + Endpunkte " unter "Meine Ressourcen " im linken Bereich aus.
Wählen Sie +Modell bereitstellen>Basismodell bereitstellen aus, um das Bereitstellungsfenster zu öffnen.
Suchen Sie nach dem Modell gpt-realtime, wählen Sie es aus, und wählen Sie dann Bestätigen aus.
Überprüfen Sie die Bereitstellungsdetails, und wählen Sie "Bereitstellen" aus.
Durchlaufen Sie den Assistenten, um die Bereitstellung des Modells abzuschließen.

Nachdem Sie nun über eine Bereitstellung des gpt-realtime Modells verfügen, können Sie mit dem Modell im Foundry-Portal Audio Playground oder Realtime API interagieren.

Verwenden von GPT-Echtzeitaudio

Führen Sie die folgenden Schritte aus, um mit Ihrem bereitgestellten gpt-realtime Modell im Microsoft FoundryEchtzeit-Audio-Playground zu chatten:

Wechseln Sie zum Foundry-Portal, und wählen Sie Ihr Projekt mit Ihrem bereitgestellten gpt-realtime Modell aus.
Wählen Sie im linken Bereich "Playgrounds" aus.
Wählen Sie Audio-Spielplatz>Audio-Spielplatz testen aus.

Hinweis

Der Chat-Playground unterstützt das gpt-realtime Modell nicht. Verwenden Sie den Audio-Playground , wie in diesem Abschnitt beschrieben.
Wählen Sie Ihr bereitgestelltes gpt-realtime-Modell aus der Dropdownliste Bereitstellung aus.
Optional können Sie Inhalte im Textfeld "Modellanweisungen und Kontext" bearbeiten. Gibt dem Modell Anweisungen dazu, wie es sich verhalten soll und auf welchen Kontext es beim Generieren einer Antwort verweisen soll. Sie können die Persönlichkeit des Assistenten beschreiben, ihm sagen, was er beantworten soll und was nicht, und ihm sagen, wie Antworten formatiert werden sollen.
Ändern Sie optional Einstellungen wie Schwellenwert, Präfixauffüllung und Stilledauer.
Wählen Sie Zuhören starten aus, um die Sitzung zu starten. Sie können in das Mikrofon sprechen, um einen Chat zu starten.
Sie können den Chat jederzeit unterbrechen, indem Sie sprechen. Sie können den Chat beenden, indem Sie die Schaltfläche " Überwachung beenden " auswählen.

Weitere Informationen zur Verwendung der Realtime-API
Siehe die Realtime-API-Referenz
Erfahren Sie mehr über Kontingente und Grenzwerte in Azure OpenAI
Weitere Informationen zu Unterstützung für Sprachen und Stimmen im Sprachdienst

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-08

Freigeben über

GPT Realtime-API für Sprache und Audio

Unterstützte Modelle

API-Unterstützung

Voraussetzungen

Voraussetzungen für Microsoft Entra ID

Bereitstellen eines Modells für Echtzeitaudio

Einrichten

Abrufen von Ressourceninformationen

Texteingabe, Audioausgabe

Output

Voraussetzungen

Voraussetzungen für Microsoft Entra ID

Bereitstellen eines Modells für Echtzeitaudio

Einrichten

Abrufen von Ressourceninformationen

Texteingabe, Audioausgabe

Output

Voraussetzungen

Voraussetzungen für Microsoft Entra ID

Bereitstellen eines Modells für Echtzeitaudio

Einrichten

Abrufen von Ressourceninformationen

Texteingabe, Audioausgabe

Output

Bereitstellen eines Modells für Echtzeitaudio

Verwenden von GPT-Echtzeitaudio

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen