Guia de início rápido: introdução ao uso da geração de áudio do Azure OpenAI

Artigo
02/25/2025

Os gpt-4o-audio-preview modelos e gpt-4o-mini-audio-preview introduzem a modalidade de áudio na API existente /chat/completions . O modelo de áudio expande o potencial para aplicações de IA em interações baseadas em texto e voz e análise de áudio. As modalidades suportadas nos gpt-4o-audio-preview modelos incluem gpt-4o-mini-audio-preview : texto, áudio e texto + áudio.

Aqui está uma tabela das modalidades suportadas com exemplos de casos de uso:

Entrada de modalidade	Modalidade de saída	Exemplo de caso de uso
Texto	Texto + áudio	Conversão de texto em fala, geração de audiolivros
Áudio	Texto + áudio	Transcrição de áudio, geração de audiolivros
Áudio	Texto	Transcrição de áudio
Texto + áudio	Texto + áudio	Geração de audiolivros
Texto + áudio	Texto	Transcrição de áudio

Usando recursos de geração de áudio, você pode obter aplicativos de IA mais dinâmicos e interativos. Os modelos que suportam entradas e saídas de áudio permitem gerar respostas de áudio falado para prompts e usar entradas de áudio para avisar o modelo.

Modelos suportados

Atualmente apenas gpt-4o-audio-preview e gpt-4o-mini-audio-preview versão: 2024-12-17 suporta geração de áudio.

Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.

Atualmente, as seguintes vozes são suportadas para saída de áudio: Alloy, Echo e Shimmer.

O tamanho máximo do ficheiro de áudio é de 20 MB.

Nota

A API em tempo real usa o mesmo modelo de áudio GPT-4o subjacente que a API de conclusão, mas é otimizada para interações de áudio em tempo real de baixa latência.

Suporte de API

O suporte para conclusão de áudio foi adicionado pela primeira vez na versão 2025-01-01-previewAPI.

Implantar um modelo para geração de áudio

Para implantar o gpt-4o-mini-audio-preview modelo no portal do Azure AI Foundry:

Vá para a página do Serviço OpenAI do Azure no portal do Azure AI Foundry. Certifique-se de que tem sessão iniciada com a subscrição do Azure que tem o seu recurso do Serviço OpenAI do Azure e o modelo implementado gpt-4o-mini-audio-preview .
Selecione o Playground de bate-papo em Playgrounds no painel esquerdo.
Selecione + Criar nova implantação>a partir de modelos base para abrir a janela de implantação.
Procure e selecione o gpt-4o-mini-audio-preview modelo e, em seguida, selecione Implantar no recurso selecionado.
No assistente de implantação, selecione a versão do 2024-12-17 modelo.
Siga o assistente para concluir a implantação do modelo.

Agora que você tem uma implantação do modelo, pode interagir com ele no playground de bate-papo do portal do Azure AI Foundry ou na API de conclusão de bate-papogpt-4o-mini-audio-preview.

Use a geração de áudio GPT-4o

Para conversar com seu modelo implantado gpt-4o-mini-audio-preview no playground de bate-papo do portal do Azure AI Foundry, siga estas etapas:

Vá para a página do Serviço OpenAI do Azure no portal do Azure AI Foundry. Certifique-se de que tem sessão iniciada com a subscrição do Azure que tem o seu recurso do Serviço OpenAI do Azure e o modelo implementado gpt-4o-mini-audio-preview .
Selecione o Playground de bate-papo em Playground de recursos no painel esquerdo.
Selecione seu modelo implantado gpt-4o-mini-audio-preview na lista suspensa Implantação .
Comece a conversar com o modelo e ouça as respostas de áudio.

Pode:
- Grave prompts de áudio.
- Anexe arquivos de áudio ao chat.
- Insira prompts de texto.

Documentação | de referência Pacote de código-fonte | da biblioteca (npm)Exemplos |

Aqui está uma tabela das modalidades suportadas com exemplos de casos de uso:

Entrada de modalidade	Modalidade de saída	Exemplo de caso de uso
Texto	Texto + áudio	Conversão de texto em fala, geração de audiolivros
Áudio	Texto + áudio	Transcrição de áudio, geração de audiolivros
Áudio	Texto	Transcrição de áudio
Texto + áudio	Texto + áudio	Geração de audiolivros
Texto + áudio	Texto	Transcrição de áudio

Modelos suportados

Atualmente apenas gpt-4o-audio-preview e gpt-4o-mini-audio-preview versão: 2024-12-17 suporta geração de áudio.

Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.

Atualmente, as seguintes vozes são suportadas para saída de áudio: Alloy, Echo e Shimmer.

O tamanho máximo do ficheiro de áudio é de 20 MB.

Nota

A API em tempo real usa o mesmo modelo de áudio GPT-4o subjacente que a API de conclusão, mas é otimizada para interações de áudio em tempo real de baixa latência.

Suporte de API

O suporte para conclusão de áudio foi adicionado pela primeira vez na versão 2025-01-01-previewAPI.

Pré-requisitos

Uma assinatura do Azure - Crie uma gratuitamente
Node.js suporte LTS ou ESM.
Um recurso OpenAI do Azure criado em uma das regiões com suporte. Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.
Em seguida, você precisa implantar um gpt-4o-mini-audio-preview modelo com seu recurso do Azure OpenAI. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Pré-requisitos do Microsoft Entra ID

Para a autenticação sem chave recomendada com o Microsoft Entra ID, você precisa:

Instale a CLI do Azure usada para autenticação sem chave com o Microsoft Entra ID.
Atribua a Cognitive Services User função à sua conta de utilizador. Você pode atribuir funções no portal do Azure em Controle de acesso (IAM)>Adicionar atribuição de função.

Configurar

Crie uma nova pasta audio-completions-quickstart para conter o aplicativo e abra o Visual Studio Code nessa pasta com o seguinte comando:
```
mkdir audio-completions-quickstart && code audio-completions-quickstart
```
Crie o package.json com o seguinte comando:
```
npm init -y
```
Atualize o package.json para ECMAScript com o seguinte comando:
```
npm pkg set type=module
```
Instale a biblioteca de cliente OpenAI para JavaScript com:
```
npm install openai
```
Para a autenticação sem chave recomendada com o Microsoft Entra ID, instale o @azure/identity pacote com:
```
npm install @azure/identity
```

Recuperar informações do recurso

Você precisa recuperar as seguintes informações para autenticar seu aplicativo com seu recurso do Azure OpenAI:

Microsoft Entra ID
Chave de API

Nome da variável	Value
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Este valor corresponderá ao nome personalizado que escolheu para a implementação quando implementou um modelo. Esse valor pode ser encontrado em Implantações de Modelo de Gerenciamento de>Recursos no portal do Azure.
`OPENAI_API_VERSION`	Saiba mais sobre as versões da API.

Saiba mais sobre autenticação sem chave e configuração de variáveis de ambiente.

Nome da variável	Value
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_API_KEY`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure. Pode utilizar `KEY1` ou `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Este valor corresponderá ao nome personalizado que escolheu para a implementação quando implementou um modelo. Esse valor pode ser encontrado em Implantações de Modelo de Gerenciamento de>Recursos no portal do Azure.
`OPENAI_API_VERSION`	Saiba mais sobre as versões da API.

Saiba mais sobre como localizar chaves de API e definir variáveis de ambiente.

Importante

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se você usar uma chave de API, armazene-a com segurança no Cofre de Chaves do Azure. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

Atenção

Para usar a autenticação sem chave recomendada com o SDK, verifique se a AZURE_OPENAI_API_KEY variável de ambiente não está definida.

Crie o to-audio.js arquivo com o seguinte código:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
const { writeFileSync } = require("node:fs");

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

// Set environment variables or edit the corresponding values here.
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    azureADTokenProvider, 
    apiVersion, 
    deployment 
}); 

async function main() {

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview", 
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: [ 
        { 
            role: "user", 
            content: "Is a golden retriever a good family dog?" 
        } 
        ] 
    }); 

// Inspect returned data 
console.log(response.choices[0]); 

// Write the output audio data to a file
writeFileSync( 
    "dog.wav", 
    Buffer.from(response.choices[0].message.audio.data, 'base64'), 
    { encoding: "utf-8" } 
); 
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

module.exports = { main };

Entre no Azure com o seguinte comando:
```
az login
```
Execute o arquivo JavaScript.
```
node to-audio.js
```

Crie o to-audio.js arquivo com o seguinte código:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const { writeFileSync } = require("node:fs");

// Set environment variables or edit the corresponding values here.
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "AZURE_OPENAI_API_KEY";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    apiKey, 
    apiVersion, 
    deployment 
});  

async function main() {

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview", 
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: [ 
        { 
            role: "user", 
            content: "Is a golden retriever a good family dog?" 
        } 
        ] 
    }); 

// Inspect returned data 
console.log(response.choices[0]); 

// Write the output audio data to a file
writeFileSync( 
    "dog.wav", 
    Buffer.from(response.choices[0].message.audio.data, 'base64'), 
    { encoding: "utf-8" } 
); 
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

module.exports = { main };

Execute o arquivo JavaScript.
```
node to-audio.js
```

Aguarde alguns instantes para obter a resposta.

Saída para geração de áudio a partir da entrada de texto

O script gera um arquivo de áudio chamado dog.wav no mesmo diretório que o script. O arquivo de áudio contém a resposta falada ao prompt: "Um golden retriever é um bom cão de família?"

Gerar áudio e texto a partir da entrada de áudio

Microsoft Entra ID
Chave de API

Crie o from-audio.js arquivo com o seguinte código:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
const fs = require('fs').promises;
const { writeFileSync } = require("node:fs");

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

// Set environment variables or edit the corresponding values here.
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    azureADTokenProvider, 
    apiVersion, 
    deployment 
});    

async function main() {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Make the audio chat completions request
    const response = await client.chat.completions.create({
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"],
        audio: { voice: "alloy", format: "wav" }, 
        messages: [
            {
                role: "user",
                content: [
                    { 
                        type: "text", 
                        text: "Describe in detail the spoken audio input." 
                    },
                    { 
                        type: "input_audio", 
                        input_audio: { 
                            data: base64str, 
                            format: "wav" 
                        } 
                    }
                ]
            }
        ]
    });

    console.log(response.choices[0]); 

    // Write the output audio data to a file
    writeFileSync( 
        "analysis.wav", 
        Buffer.from(response.choices[0].message.audio.data, 'base64'), 
        { encoding: "utf-8" } 
    ); 
}

main().catch((err) => {
    console.error("Error occurred:", err);
});

module.exports = { main };

Entre no Azure com o seguinte comando:
```
az login
```
Execute o arquivo JavaScript.
```
node from-audio.js
```

Crie o from-audio.js arquivo com o seguinte código:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const fs = require('fs').promises;
const { writeFileSync } = require("node:fs");

// Set environment variables or edit the corresponding values here.
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "AZURE_OPENAI_API_KEY";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    apiKey, 
    apiVersion, 
    deployment 
});  

async function main() {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Make the audio chat completions request
    const response = await client.chat.completions.create({
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"],
        audio: { voice: "alloy", format: "wav" }, 
        messages: [
            {
                role: "user",
                content: [
                    { 
                        type: "text", 
                        text: "Describe in detail the spoken audio input." 
                    },
                    { 
                        type: "input_audio", 
                        input_audio: { 
                            data: base64str, 
                            format: "wav" 
                        } 
                    }
                ]
            }
        ]
    });

    console.log(response.choices[0]); 

    // Write the output audio data to a file
    writeFileSync( 
        "analysis.wav", 
        Buffer.from(response.choices[0].message.audio.data, 'base64'), 
        { encoding: "utf-8" } 
    ); 
}

main().catch((err) => {
    console.error("Error occurred:", err);
});

module.exports = { main };

Execute o arquivo JavaScript.
```
node from-audio.js
```

Aguarde alguns instantes para obter a resposta.

Saída para geração de áudio e texto a partir da entrada de áudio

O script gera uma transcrição do resumo da entrada de áudio falado. Ele também gera um arquivo de áudio chamado analysis.wav no mesmo diretório que o script. O arquivo de áudio contém a resposta falada ao prompt.

Gere áudio e use finalizações de bate-papo em várias voltas

Microsoft Entra ID
Chave de API

Crie o multi-turn.js arquivo com o seguinte código:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
const fs = require('fs').promises;

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

// Set environment variables or edit the corresponding values here.
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    azureADTokenProvider, 
    apiVersion, 
    deployment 
}); 

async function main() {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Initialize messages with the first turn's user input 
    const messages = [
        {
            role: "user",
            content: [
                { 
                    type: "text", 
                    text: "Describe in detail the spoken audio input." 
                },
                { 
                    type: "input_audio", 
                    input_audio: { 
                        data: base64str, 
                        format: "wav" 
                    } 
                }
            ]
        }
    ];

    // Get the first turn's response 

    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: messages
    }); 

    console.log(response.choices[0]); 

    // Add a history message referencing the previous turn's audio by ID 
    messages.push({ 
        role: "assistant", 
        audio: { id: response.choices[0].message.audio.id }
    });

    // Add a new user message for the second turn
    messages.push({ 
        role: "user", 
        content: [ 
            { 
                type: "text", 
                text: "Very concisely summarize the favorability." 
            } 
        ] 
    }); 

    // Send the follow-up request with the accumulated messages
    const followResponse = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        messages: messages
    });

    console.log(followResponse.choices[0].message.content); 
}

main().catch((err) => {
    console.error("Error occurred:", err);
});

module.exports = { main };

Entre no Azure com o seguinte comando:
```
az login
```
Execute o arquivo JavaScript.
```
node multi-turn.js
```

Crie o multi-turn.js arquivo com o seguinte código:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const fs = require('fs').promises;

// Set environment variables or edit the corresponding values here.
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "AZURE_OPENAI_API_KEY";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    apiKey, 
    apiVersion, 
    deployment 
});  

async function main() {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Initialize messages with the first turn's user input 
    const messages = [
        {
            role: "user",
            content: [
                { 
                    type: "text", 
                    text: "Describe in detail the spoken audio input." 
                },
                { 
                    type: "input_audio", 
                    input_audio: { 
                        data: base64str, 
                        format: "wav" 
                    } 
                }
            ]
        }
    ];

    // Get the first turn's response 

    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: messages
    }); 

    console.log(response.choices[0]); 

    // Add a history message referencing the previous turn's audio by ID 
    messages.push({ 
        role: "assistant", 
        audio: { id: response.choices[0].message.audio.id }
    });

    // Add a new user message for the second turn
    messages.push({ 
        role: "user", 
        content: [ 
            { 
                type: "text", 
                text: "Very concisely summarize the favorability." 
            } 
        ] 
    }); 

    // Send the follow-up request with the accumulated messages
    const followResponse = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        messages: messages
    });

    console.log(followResponse.choices[0].message.content); 
}

main().catch((err) => {
    console.error("Error occurred:", err);
});

module.exports = { main };

Execute o arquivo JavaScript.
```
node multi-turn.js
```

Aguarde alguns instantes para obter a resposta.

Saída para conclusão de bate-papo em vários turnos

O script gera uma transcrição do resumo da entrada de áudio falado. Em seguida, ele faz uma conclusão de bate-papo de várias voltas para resumir brevemente a entrada de áudio falado.

Exemplos de pacotes | de código-fonte | da biblioteca

Aqui está uma tabela das modalidades suportadas com exemplos de casos de uso:

Entrada de modalidade	Modalidade de saída	Exemplo de caso de uso
Texto	Texto + áudio	Conversão de texto em fala, geração de audiolivros
Áudio	Texto + áudio	Transcrição de áudio, geração de audiolivros
Áudio	Texto	Transcrição de áudio
Texto + áudio	Texto + áudio	Geração de audiolivros
Texto + áudio	Texto	Transcrição de áudio

Modelos suportados

Atualmente apenas gpt-4o-audio-preview e gpt-4o-mini-audio-preview versão: 2024-12-17 suporta geração de áudio.

Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.

Atualmente, as seguintes vozes são suportadas para saída de áudio: Alloy, Echo e Shimmer.

O tamanho máximo do ficheiro de áudio é de 20 MB.

Nota

A API em tempo real usa o mesmo modelo de áudio GPT-4o subjacente que a API de conclusão, mas é otimizada para interações de áudio em tempo real de baixa latência.

Suporte de API

O suporte para conclusão de áudio foi adicionado pela primeira vez na versão 2025-01-01-previewAPI.

Use este guia para começar a gerar áudio com o SDK do Azure OpenAI para Python.

Pré-requisitos

Uma subscrição do Azure. Crie um gratuitamente.
Python 3.8 ou versão posterior. Recomendamos o uso do Python 3.10 ou posterior, mas é necessário ter pelo menos o Python 3.8. Se você não tiver uma versão adequada do Python instalada, você pode seguir as instruções no VS Code Python Tutorial para a maneira mais fácil de instalar o Python em seu sistema operacional.
Um recurso OpenAI do Azure criado em uma das regiões com suporte. Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.
Em seguida, você precisa implantar um gpt-4o-mini-audio-preview modelo com seu recurso do Azure OpenAI. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Pré-requisitos do Microsoft Entra ID

Para a autenticação sem chave recomendada com o Microsoft Entra ID, você precisa:

Instale a CLI do Azure usada para autenticação sem chave com o Microsoft Entra ID.
Atribua a Cognitive Services User função à sua conta de utilizador. Você pode atribuir funções no portal do Azure em Controle de acesso (IAM)>Adicionar atribuição de função.

Configurar

Crie uma nova pasta audio-completions-quickstart para conter o aplicativo e abra o Visual Studio Code nessa pasta com o seguinte comando:
```
mkdir audio-completions-quickstart && code audio-completions-quickstart
```
Crie um ambiente virtual. Se você já tiver o Python 3.10 ou superior instalado, poderá criar um ambiente virtual usando os seguintes comandos:
- 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
```
Ativar o ambiente Python significa que quando você executa python ou pip a partir da linha de comando, você usa o interpretador Python contido na .venv pasta do seu aplicativo. Você pode usar o deactivate comando para sair do ambiente virtual python e, posteriormente, reativá-lo quando necessário.

Gorjeta

Recomendamos que você crie e ative um novo ambiente Python para usar para instalar os pacotes necessários para este tutorial. Não instale pacotes em sua instalação global do python. Você deve sempre usar um ambiente virtual ou conda ao instalar pacotes python, caso contrário, você pode quebrar sua instalação global do Python.
Instale a biblioteca de cliente OpenAI para Python com:
```
pip install openai
```
Para a autenticação sem chave recomendada com o Microsoft Entra ID, instale o azure-identity pacote com:
```
pip install azure-identity
```

Recuperar informações do recurso

Você precisa recuperar as seguintes informações para autenticar seu aplicativo com seu recurso do Azure OpenAI:

Microsoft Entra ID
Chave de API

Nome da variável	Value
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Este valor corresponderá ao nome personalizado que escolheu para a implementação quando implementou um modelo. Esse valor pode ser encontrado em Implantações de Modelo de Gerenciamento de>Recursos no portal do Azure.
`OPENAI_API_VERSION`	Saiba mais sobre as versões da API.

Saiba mais sobre autenticação sem chave e configuração de variáveis de ambiente.

Nome da variável	Value
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_API_KEY`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure. Pode utilizar `KEY1` ou `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Este valor corresponderá ao nome personalizado que escolheu para a implementação quando implementou um modelo. Esse valor pode ser encontrado em Implantações de Modelo de Gerenciamento de>Recursos no portal do Azure.
`OPENAI_API_VERSION`	Saiba mais sobre as versões da API.

Saiba mais sobre como localizar chaves de API e definir variáveis de ambiente.

Importante

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

Gerar áudio a partir da entrada de texto

Microsoft Entra ID
Chave de API

Crie o to-audio.py arquivo com o seguinte código:

import requests
import base64 
import os 
from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

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

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
client=AzureOpenAI(
    azure_ad_token_provider=token_provider,
    azure_endpoint=endpoint,
    api_version="2025-01-01-preview"
)

# Make the audio chat completions request
completion=client.chat.completions.create(
    model="gpt-4o-mini-audio-preview",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[
        {
            "role": "user",
            "content": "Is a golden retriever a good family dog?"
        }
    ]
)

print(completion.choices[0])

# Write the output audio data to a file
wav_bytes=base64.b64decode(completion.choices[0].message.audio.data)
with open("dog.wav", "wb") as f:
    f.write(wav_bytes)

Execute o arquivo Python.
```
python to-audio.py
```

Crie o to-audio.py arquivo com o seguinte código:

import base64 
import os 
from openai import AzureOpenAI 

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

client = AzureOpenAI(
    api_version="2025-01-01-preview",  
    api_key=api_key,
    azure_endpoint=endpoint
)

# Make the audio chat completions request
completion = client.chat.completions.create(
    model="gpt-4o-mini-audio-preview",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[
        {
            "role": "user",
            "content": "Is a golden retriever a good family dog?"
        }
    ]
)

print(completion.choices[0])

# Write the output audio data to a file
wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
with open("dog.wav", "wb") as f:
    f.write(wav_bytes)

Execute o arquivo Python.
```
python to-audio.py
```

Aguarde alguns instantes para obter a resposta.

Saída para geração de áudio a partir da entrada de texto

O script gera um arquivo de áudio chamado dog.wav no mesmo diretório que o script. O arquivo de áudio contém a resposta falada ao prompt: "Um golden retriever é um bom cão de família?"

Gerar áudio e texto a partir da entrada de áudio

Microsoft Entra ID
Chave de API

Crie o from-audio.py arquivo com o seguinte código:

import base64
import os
from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

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

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
client=AzureOpenAI(
    azure_ad_token_provider=token_provider,
    azure_endpoint=endpoint
    api_version="2025-01-01-preview"
)

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
    encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Make the audio chat completions request
completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    modalities=["text", "audio"], 
    audio={"voice": "alloy", "format": "wav"}, 
    messages=[ 
        { 
            "role": "user", 
            "content": [ 
                {  
                    "type": "text", 
                    "text": "Describe in detail the spoken audio input." 
                }, 
                { 
                    "type": "input_audio", 
                    "input_audio": { 
                        "data": encoded_string, 
                        "format": "wav" 
                    } 
                } 
            ] 
        }, 
    ] 
) 

print(completion.choices[0].message.audio.transcript)

# Write the output audio data to a file
wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
with open("analysis.wav", "wb") as f:
    f.write(wav_bytes)

Execute o arquivo Python.
```
python from-audio.py
```

Crie o from-audio.py arquivo com o seguinte código:

import base64
import os
from openai import AzureOpenAI

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

client = AzureOpenAI(
    api_version="2025-01-01-preview",  
    api_key=api_key, 
    azure_endpoint=endpoint
)

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
    encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Make the audio chat completions request
completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    modalities=["text", "audio"], 
    audio={"voice": "alloy", "format": "wav"}, 
    messages=[ 
        { 
            "role": "user", 
            "content": [ 
                {  
                    "type": "text", 
                    "text": "Describe in detail the spoken audio input." 
                }, 
                { 
                    "type": "input_audio", 
                    "input_audio": { 
                        "data": encoded_string, 
                        "format": "wav" 
                    } 
                } 
            ] 
        }, 
    ] 
) 

print(completion.choices[0].message.audio.transcript)

# Write the output audio data to a file
wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
with open("analysis.wav", "wb") as f:
    f.write(wav_bytes)

Execute o arquivo Python.
```
python from-audio.py
```

Aguarde alguns instantes para obter a resposta.

Saída para geração de áudio e texto a partir da entrada de áudio

Gere áudio e use finalizações de bate-papo em várias voltas

Microsoft Entra ID
Chave de API

Crie o multi-turn.py arquivo com o seguinte código:

import base64 
import os 
from openai import AzureOpenAI 
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

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

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
client=AzureOpenAI(
    azure_ad_token_provider=token_provider,
    azure_endpoint=endpoint,
    api_version="2025-01-01-preview"
)

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
    encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Initialize messages with the first turn's user input 
messages = [
    { 
        "role": "user", 
        "content": [ 
            { "type": "text", "text": "Describe in detail the spoken audio input." }, 
            { "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }] 

# Get the first turn's response

completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    modalities=["text", "audio"], 
    audio={"voice": "alloy", "format": "wav"}, 
    messages=messages
) 

print("Get the first turn's response:")
print(completion.choices[0].message.audio.transcript) 

print("Add a history message referencing the first turn's audio by ID:")
print(completion.choices[0].message.audio.id)

# Add a history message referencing the first turn's audio by ID 
messages.append({ 
    "role": "assistant", 
    "audio": { "id": completion.choices[0].message.audio.id } 
}) 

# Add the next turn's user message 
messages.append({ 
    "role": "user", 
    "content": "Very briefly, summarize the favorability." 
}) 

# Send the follow-up request with the accumulated messages
completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    messages=messages
) 

print("Very briefly, summarize the favorability.")
print(completion.choices[0].message.content)

Execute o arquivo Python.
```
python multi-turn.py
```

Crie o multi-turn.py arquivo com o seguinte código:

import base64 
import os 
from openai import AzureOpenAI 

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

client = AzureOpenAI(
    api_version="2025-01-01-preview",  
    api_key=api_key, 
    azure_endpoint=endpoint
)

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
    encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Initialize messages with the first turn's user input 
messages = [
    { 
        "role": "user", 
        "content": [ 
            { "type": "text", "text": "Describe in detail the spoken audio input." }, 
            { "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }] 

# Get the first turn's response 

completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    modalities=["text", "audio"], 
    audio={"voice": "alloy", "format": "wav"}, 
    messages=messages
) 

print("Get the first turn's response:")
print(completion.choices[0].message.audio.transcript) 

print("Add a history message referencing the first turn's audio by ID:")
print(completion.choices[0].message.audio.id)

# Add a history message referencing the first turn's audio by ID 
messages.append({ 
    "role": "assistant", 
    "audio": { "id": completion.choices[0].message.audio.id } 
}) 

# Add the next turn's user message 
messages.append({ 
    "role": "user", 
    "content": "Very briefly, summarize the favorability." 
}) 

# Send the follow-up request with the accumulated messages 
completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    messages=messages
) 

print("Very briefly, summarize the favorability.")
print(completion.choices[0].message.content)

Execute o arquivo Python.
```
python multi-turn.py
```

Aguarde alguns instantes para obter a resposta.

Saída para conclusão de bate-papo em vários turnos

O script gera uma transcrição do resumo da entrada de áudio falado. Em seguida, ele faz uma conclusão de bate-papo de várias voltas para resumir brevemente a entrada de áudio falado.

Especificação da API REST |

Aqui está uma tabela das modalidades suportadas com exemplos de casos de uso:

Entrada de modalidade	Modalidade de saída	Exemplo de caso de uso
Texto	Texto + áudio	Conversão de texto em fala, geração de audiolivros
Áudio	Texto + áudio	Transcrição de áudio, geração de audiolivros
Áudio	Texto	Transcrição de áudio
Texto + áudio	Texto + áudio	Geração de audiolivros
Texto + áudio	Texto	Transcrição de áudio

Modelos suportados

Atualmente apenas gpt-4o-audio-preview e gpt-4o-mini-audio-preview versão: 2024-12-17 suporta geração de áudio.

Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.

Atualmente, as seguintes vozes são suportadas para saída de áudio: Alloy, Echo e Shimmer.

O tamanho máximo do ficheiro de áudio é de 20 MB.

Nota

A API em tempo real usa o mesmo modelo de áudio GPT-4o subjacente que a API de conclusão, mas é otimizada para interações de áudio em tempo real de baixa latência.

Suporte de API

O suporte para conclusão de áudio foi adicionado pela primeira vez na versão 2025-01-01-previewAPI.

Pré-requisitos

Uma subscrição do Azure. Crie um gratuitamente.
Python 3.8 ou versão posterior. Recomendamos o uso do Python 3.10 ou posterior, mas é necessário ter pelo menos o Python 3.8. Se você não tiver uma versão adequada do Python instalada, você pode seguir as instruções no VS Code Python Tutorial para a maneira mais fácil de instalar o Python em seu sistema operacional.
Um recurso OpenAI do Azure criado em uma das regiões com suporte. Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.
Em seguida, você precisa implantar um gpt-4o-mini-audio-preview modelo com seu recurso do Azure OpenAI. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Pré-requisitos do Microsoft Entra ID

Para a autenticação sem chave recomendada com o Microsoft Entra ID, você precisa:

Instale a CLI do Azure usada para autenticação sem chave com o Microsoft Entra ID.
Atribua a Cognitive Services User função à sua conta de utilizador. Você pode atribuir funções no portal do Azure em Controle de acesso (IAM)>Adicionar atribuição de função.

Configurar

Crie uma nova pasta audio-completions-quickstart para conter o aplicativo e abra o Visual Studio Code nessa pasta com o seguinte comando:
```
mkdir audio-completions-quickstart && code audio-completions-quickstart
```
Crie um ambiente virtual. Se você já tiver o Python 3.10 ou superior instalado, poderá criar um ambiente virtual usando os seguintes comandos:
- 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
```
Ativar o ambiente Python significa que quando você executa python ou pip a partir da linha de comando, você usa o interpretador Python contido na .venv pasta do seu aplicativo. Você pode usar o deactivate comando para sair do ambiente virtual python e, posteriormente, reativá-lo quando necessário.

Gorjeta

Recomendamos que você crie e ative um novo ambiente Python para usar para instalar os pacotes necessários para este tutorial. Não instale pacotes em sua instalação global do python. Você deve sempre usar um ambiente virtual ou conda ao instalar pacotes python, caso contrário, você pode quebrar sua instalação global do Python.
Instale a biblioteca de cliente OpenAI para Python com:
```
pip install openai
```
Para a autenticação sem chave recomendada com o Microsoft Entra ID, instale o azure-identity pacote com:
```
pip install azure-identity
```

Recuperar informações do recurso

Você precisa recuperar as seguintes informações para autenticar seu aplicativo com seu recurso do Azure OpenAI:

Microsoft Entra ID
Chave de API

Nome da variável	Value
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Este valor corresponderá ao nome personalizado que escolheu para a implementação quando implementou um modelo. Esse valor pode ser encontrado em Implantações de Modelo de Gerenciamento de>Recursos no portal do Azure.
`OPENAI_API_VERSION`	Saiba mais sobre as versões da API.

Saiba mais sobre autenticação sem chave e configuração de variáveis de ambiente.

Nome da variável	Value
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_API_KEY`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure. Pode utilizar `KEY1` ou `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Este valor corresponderá ao nome personalizado que escolheu para a implementação quando implementou um modelo. Esse valor pode ser encontrado em Implantações de Modelo de Gerenciamento de>Recursos no portal do Azure.
`OPENAI_API_VERSION`	Saiba mais sobre as versões da API.

Saiba mais sobre como localizar chaves de API e definir variáveis de ambiente.

Importante

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

Gerar áudio a partir da entrada de texto

Microsoft Entra ID
Chave de API

Crie o to-audio.py arquivo com o seguinte código:

import requests
import base64 
import os 
from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
credential = DefaultAzureCredential()
token = credential.get_token("https://cognitiveservices.azure.com/.default")

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Is a golden retriever a good family dog?"
        }
      ]
    }
  ]
}

# Make the audio chat completions request
completion = requests.post(url, headers=headers, json=body)
audio_data = completion.json()['choices'][0]['message']['audio']['data']

# Write the output audio data to a file
wav_bytes = base64.b64decode(audio_data)
with open("dog.wav", "wb") as f: 
  f.write(wav_bytes)

Execute o arquivo Python.
```
python to-audio.py
```

Crie o to-audio.py arquivo com o seguinte código:

import requests
import base64 
import os 
from openai import AzureOpenAI 

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }
body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Is a golden retriever a good family dog?"
        }
      ]
    }
  ]
}

# Make the audio chat completions request
completion = requests.post(url, headers=headers, json=body)
audio_data = completion.json()['choices'][0]['message']['audio']['data']

# Write the output audio data to a file 
wav_bytes = base64.b64decode(audio_data)
with open("dog.wav", "wb") as f: 
  f.write(wav_bytes)

Execute o arquivo Python.
```
python to-audio.py
```

Aguarde alguns instantes para obter a resposta.

Saída para geração de áudio a partir da entrada de texto

O script gera um arquivo de áudio chamado dog.wav no mesmo diretório que o script. O arquivo de áudio contém a resposta falada ao prompt: "Um golden retriever é um bom cão de família?"

Gerar áudio e texto a partir da entrada de áudio

Microsoft Entra ID
Chave de API

Crie o from-audio.py arquivo com o seguinte código:

import requests
import base64
import os
from azure.identity import DefaultAzureCredential

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
credential = DefaultAzureCredential()
token = credential.get_token("https://cognitiveservices.azure.com/.default")

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
  encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": [
    { 
        "role": "user", 
        "content": [ 
            {  
                "type": "text", 
                "text": "Describe in detail the spoken audio input." 
            }, 
            { 
                "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }, 
  ]
}

completion = requests.post(url, headers=headers, json=body)

print(completion.json()['choices'][0]['message']['audio']['transcript'])

# Write the output audio data to a file
audio_data = completion.json()['choices'][0]['message']['audio']['data'] 
wav_bytes = base64.b64decode(audio_data)
with open("analysis.wav", "wb") as f: 
  f.write(wav_bytes)

Execute o arquivo Python.
```
python from-audio.py
```

Crie o from-audio.py arquivo com o seguinte código:

import requests
import base64
import os

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
  encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }
body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": [
    { 
        "role": "user", 
        "content": [ 
            {  
                "type": "text", 
                "text": "Describe in detail the spoken audio input." 
            }, 
            { 
                "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }, 
  ]
}

completion = requests.post(url, headers=headers, json=body)

print(completion.json()['choices'][0]['message']['audio']['transcript'])

# Write the output audio data to a file
audio_data = completion.json()['choices'][0]['message']['audio']['data'] 
wav_bytes = base64.b64decode(audio_data)
with open("analysis.wav", "wb") as f: 
  f.write(wav_bytes)

Execute o arquivo Python.
```
python from-audio.py
```

Aguarde alguns instantes para obter a resposta.

Saída para geração de áudio e texto a partir da entrada de áudio

Gere áudio e use finalizações de bate-papo em várias voltas

Microsoft Entra ID
Chave de API

Crie o multi-turn.py arquivo com o seguinte código:

import requests
import base64 
import os 
from openai import AzureOpenAI 
from azure.identity import DefaultAzureCredential

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
credential = DefaultAzureCredential()
token = credential.get_token("https://cognitiveservices.azure.com/.default")

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
  encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Initialize messages with the first turn's user input 
messages = [
    { 
        "role": "user", 
        "content": [ 
            {  
                "type": "text", 
                "text": "Describe in detail the spoken audio input." 
            }, 
            { 
                "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }] 

body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": messages
}

# Get the first turn's response, including generated audio 
completion = requests.post(url, headers=headers, json=body)

print("Get the first turn's response:")
print(completion.json()['choices'][0]['message']['audio']['transcript']) 

print("Add a history message referencing the first turn's audio by ID:")
print(completion.json()['choices'][0]['message']['audio']['id'])

# Add a history message referencing the first turn's audio by ID 
messages.append({ 
    "role": "assistant", 
    "audio": { "id": completion.json()['choices'][0]['message']['audio']['id'] } 
}) 

# Add the next turn's user message 
messages.append({ 
    "role": "user", 
    "content": "Very briefly, summarize the favorability." 
}) 

body = {
  "model": "gpt-4o-mini-audio-preview",
  "messages": messages
}

# Send the follow-up request with the accumulated messages
completion = requests.post(url, headers=headers, json=body) 

print("Very briefly, summarize the favorability.")
print(completion.json()['choices'][0]['message']['content'])

Execute o arquivo Python.
```
python multi-turn.py
```

Crie o multi-turn.py arquivo com o seguinte código:

import requests
import base64 
import os 
from openai import AzureOpenAI 

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
  encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Initialize messages with the first turn's user input 
messages = [
    { 
        "role": "user", 
        "content": [ 
            {  
                "type": "text", 
                "text": "Describe in detail the spoken audio input." 
            }, 
            { 
                "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }] 

body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": messages
}


# Get the first turn's response, including generated audio 
completion = requests.post(url, headers=headers, json=body)

print("Get the first turn's response:")
print(completion.json()['choices'][0]['message']['audio']['transcript']) 

print("Add a history message referencing the first turn's audio by ID:")
print(completion.json()['choices'][0]['message']['audio']['id'])

# Add a history message referencing the first turn's audio by ID 
messages.append({ 
    "role": "assistant", 
    "audio": { "id": completion.json()['choices'][0]['message']['audio']['id'] } 
}) 

# Add the next turn's user message 
messages.append({ 
    "role": "user", 
    "content": "Very briefly, summarize the favorability." 
}) 

body = {
  "model": "gpt-4o-mini-audio-preview",
  "messages": messages
}

# Send the follow-up request with the accumulated messages
completion = requests.post(url, headers=headers, json=body) 

print("Very briefly, summarize the favorability.")
print(completion.json()['choices'][0]['message']['content'])

Execute o arquivo Python.
```
python multi-turn.py
```

Aguarde alguns instantes para obter a resposta.

Saída para conclusão de bate-papo em vários turnos

O script gera uma transcrição do resumo da entrada de áudio falado. Em seguida, ele faz uma conclusão de bate-papo de várias voltas para resumir brevemente a entrada de áudio falado.

Documentação | de referência Pacote de código-fonte | da biblioteca (npm)Exemplos |

Aqui está uma tabela das modalidades suportadas com exemplos de casos de uso:

Entrada de modalidade	Modalidade de saída	Exemplo de caso de uso
Texto	Texto + áudio	Conversão de texto em fala, geração de audiolivros
Áudio	Texto + áudio	Transcrição de áudio, geração de audiolivros
Áudio	Texto	Transcrição de áudio
Texto + áudio	Texto + áudio	Geração de audiolivros
Texto + áudio	Texto	Transcrição de áudio

Modelos suportados

Atualmente apenas gpt-4o-audio-preview e gpt-4o-mini-audio-preview versão: 2024-12-17 suporta geração de áudio.

Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.

Atualmente, as seguintes vozes são suportadas para saída de áudio: Alloy, Echo e Shimmer.

O tamanho máximo do ficheiro de áudio é de 20 MB.

Nota

A API em tempo real usa o mesmo modelo de áudio GPT-4o subjacente que a API de conclusão, mas é otimizada para interações de áudio em tempo real de baixa latência.

Suporte de API

O suporte para conclusão de áudio foi adicionado pela primeira vez na versão 2025-01-01-previewAPI.

Pré-requisitos

Uma assinatura do Azure - Crie uma gratuitamente
Node.js suporte LTS ou ESM.
TypeScript instalado globalmente.
Um recurso OpenAI do Azure criado em uma das regiões com suporte. Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.
Em seguida, você precisa implantar um gpt-4o-mini-audio-preview modelo com seu recurso do Azure OpenAI. Para obter mais informações, consulte Criar um recurso e implantar um modelo com o Azure OpenAI.

Pré-requisitos do Microsoft Entra ID

Para a autenticação sem chave recomendada com o Microsoft Entra ID, você precisa:

Instale a CLI do Azure usada para autenticação sem chave com o Microsoft Entra ID.
Atribua a Cognitive Services User função à sua conta de utilizador. Você pode atribuir funções no portal do Azure em Controle de acesso (IAM)>Adicionar atribuição de função.

Configurar

Crie uma nova pasta audio-completions-quickstart para conter o aplicativo e abra o Visual Studio Code nessa pasta com o seguinte comando:
```
mkdir audio-completions-quickstart && code audio-completions-quickstart
```
Crie o package.json com o seguinte comando:
```
npm init -y
```
Atualize o package.json para ECMAScript com o seguinte comando:
```
npm pkg set type=module
```
Instale a biblioteca de cliente OpenAI para JavaScript com:
```
npm install openai
```
Para a autenticação sem chave recomendada com o Microsoft Entra ID, instale o @azure/identity pacote com:
```
npm install @azure/identity
```

Recuperar informações do recurso

Você precisa recuperar as seguintes informações para autenticar seu aplicativo com seu recurso do Azure OpenAI:

Microsoft Entra ID
Chave de API

Nome da variável	Value
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Este valor corresponderá ao nome personalizado que escolheu para a implementação quando implementou um modelo. Esse valor pode ser encontrado em Implantações de Modelo de Gerenciamento de>Recursos no portal do Azure.
`OPENAI_API_VERSION`	Saiba mais sobre as versões da API.

Saiba mais sobre autenticação sem chave e configuração de variáveis de ambiente.

Nome da variável	Value
`AZURE_OPENAI_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure.
`AZURE_OPENAI_API_KEY`	Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no portal do Azure. Pode utilizar `KEY1` ou `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Este valor corresponderá ao nome personalizado que escolheu para a implementação quando implementou um modelo. Esse valor pode ser encontrado em Implantações de Modelo de Gerenciamento de>Recursos no portal do Azure.
`OPENAI_API_VERSION`	Saiba mais sobre as versões da API.

Saiba mais sobre como localizar chaves de API e definir variáveis de ambiente.

Importante

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

Atenção

Para usar a autenticação sem chave recomendada com o SDK, verifique se a AZURE_OPENAI_API_KEY variável de ambiente não está definida.

Gerar áudio a partir da entrada de texto

Microsoft Entra ID
Chave de API

Crie o to-audio.ts arquivo com o seguinte código:

import { writeFileSync } from "node:fs";
import { AzureOpenAI } from "openai/index.mjs";
import {
    DefaultAzureCredential,
    getBearerTokenProvider,
  } from "@azure/identity";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

// Keyless authentication 
const getClient = (): AzureOpenAI => {
    const credential = new DefaultAzureCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const client = new AzureOpenAI({
      endpoint: endpoint,
      apiVersion: apiVersion,
      azureADTokenProvider,
    });
    return client;
};

const client = getClient();

async function main(): Promise<void> {

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview", 
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: [ 
        { 
            role: "user", 
            content: "Is a golden retriever a good family dog?" 
        } 
        ] 
    }); 

  // Inspect returned data 
  console.log(response.choices[0]); 

  // Write the output audio data to a file
  if (response.choices[0].message.audio) {
    writeFileSync( 
      "dog.wav", 
      Buffer.from(response.choices[0].message.audio.data, 'base64'), 
      { encoding: "utf-8" } 
    ); 
  } else {
    console.error("Audio data is null or undefined.");
  }
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Crie o tsconfig.json arquivo para transpilar o código TypeScript e copie o código a seguir para 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"]
}

Transpile de TypeScript para JavaScript.
```
tsc
```
Entre no Azure com o seguinte comando:
```
az login
```
Execute o código com o seguinte comando:
```
node to-audio.js
```

Crie o to-audio.ts arquivo com o seguinte código:

import { writeFileSync } from "node:fs";
import { AzureOpenAI } from "openai/index.mjs";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiKey: string = process.env["AZURE_OPENAI_API_KEY"] || "AZURE_OPENAI_API_KEY";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
  endpoint, 
  apiKey, 
  apiVersion, 
  deployment 
});  

async function main(): Promise<void> {

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview", 
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: [ 
        { 
            role: "user", 
            content: "Is a golden retriever a good family dog?" 
        } 
        ] 
    }); 

  // Inspect returned data 
  console.log(response.choices[0]); 

  // Write the output audio data to a file
  if (response.choices[0].message.audio) {
    writeFileSync( 
      "dog.wav", 
      Buffer.from(response.choices[0].message.audio.data, 'base64'), 
      { encoding: "utf-8" } 
    ); 
  } else {
    console.error("Audio data is null or undefined.");
  }
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Crie o tsconfig.json arquivo para transpilar o código TypeScript e copie o código a seguir para 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"]
}

Transpile de TypeScript para JavaScript.
```
tsc
```
Execute o código com o seguinte comando:
```
node to-audio.js
```

Aguarde alguns instantes para obter a resposta.

Saída para geração de áudio a partir da entrada de texto

O script gera um arquivo de áudio chamado dog.wav no mesmo diretório que o script. O arquivo de áudio contém a resposta falada ao prompt: "Um golden retriever é um bom cão de família?"

Gerar áudio e texto a partir da entrada de áudio

Microsoft Entra ID
Chave de API

Crie o from-audio.ts arquivo com o seguinte código:

import { AzureOpenAI } from "openai";
import { writeFileSync } from "node:fs";
import { promises as fs } from 'fs';
import {
    DefaultAzureCredential,
    getBearerTokenProvider,
  } from "@azure/identity";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

// Keyless authentication 
const getClient = (): AzureOpenAI => {
    const credential = new DefaultAzureCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const client = new AzureOpenAI({
      endpoint: endpoint,
      apiVersion: apiVersion,
      azureADTokenProvider,
    });
    return client;
};

const client = getClient();

async function main(): Promise<void> {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
      model: "gpt-4o-mini-audio-preview",
      modalities: ["text", "audio"], 
      audio: { voice: "alloy", format: "wav" },
      messages: [ 
        { 
          role: "user", 
          content: [ 
            { 
              type: "text", 
              text: "Describe in detail the spoken audio input." 
            }, 
            { 
              type: "input_audio", 
              input_audio: { 
                data: base64str, 
                format: "wav" 
              } 
            } 
          ] 
        } 
      ] 
    }); 

    console.log(response.choices[0]); 

    // Write the output audio data to a file
    if (response.choices[0].message.audio) {
        writeFileSync("analysis.wav", Buffer.from(response.choices[0].message.audio.data, 'base64'), { encoding: "utf-8" });
    }
    else {
        console.error("Audio data is null or undefined.");
  }
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Crie o tsconfig.json arquivo para transpilar o código TypeScript e copie o código a seguir para 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"]
}

Transpile de TypeScript para JavaScript.
```
tsc
```
Entre no Azure com o seguinte comando:
```
az login
```
Execute o código com o seguinte comando:
```
node from-audio.js
```

Crie o from-audio.ts arquivo com o seguinte código:

import { AzureOpenAI } from "openai";
import { writeFileSync } from "node:fs";
import { promises as fs } from 'fs';

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiKey: string = process.env["AZURE_OPENAI_API_KEY"] || "AZURE_OPENAI_API_KEY";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
  endpoint, 
  apiKey, 
  apiVersion, 
  deployment 
});  

async function main(): Promise<void> {

  // Buffer the audio for input to the chat completion
  const wavBuffer = await fs.readFile("dog.wav"); 
  const base64str = Buffer.from(wavBuffer).toString("base64"); 

  // Make the audio chat completions request
  const response = await client.chat.completions.create({ 
    model: "gpt-4o-mini-audio-preview",
    modalities: ["text", "audio"], 
    audio: { voice: "alloy", format: "wav" },
    messages: [ 
      { 
        role: "user", 
        content: [ 
          { 
            type: "text", 
            text: "Describe in detail the spoken audio input." 
          }, 
          { 
            type: "input_audio", 
            input_audio: { 
              data: base64str, 
              format: "wav" 
            } 
          } 
        ] 
      } 
    ] 
  }); 

  console.log(response.choices[0]); 

  // Write the output audio data to a file
  if (response.choices[0].message.audio) {
      writeFileSync("analysis.wav", Buffer.from(response.choices[0].message.audio.data, 'base64'), { encoding: "utf-8" });
  }
  else {
      console.error("Audio data is null or undefined.");
}
}

main().catch((err: Error) => {
console.error("Error occurred:", err);
});

export { main };

Crie o tsconfig.json arquivo para transpilar o código TypeScript e copie o código a seguir para 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"]
}

Transpile de TypeScript para JavaScript.
```
tsc
```
Execute o código com o seguinte comando:
```
node from-audio.js
```

Aguarde alguns instantes para obter a resposta.

Saída para geração de áudio e texto a partir da entrada de áudio

Gere áudio e use finalizações de bate-papo em várias voltas

Microsoft Entra ID
Chave de API

Crie o multi-turn.ts arquivo com o seguinte código:

import { AzureOpenAI } from "openai/index.mjs";
import { promises as fs } from 'fs';
import { ChatCompletionMessageParam } from "openai/resources/index.mjs";
import {
    DefaultAzureCredential,
    getBearerTokenProvider,
  } from "@azure/identity";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

// Keyless authentication 
const getClient = (): AzureOpenAI => {
    const credential = new DefaultAzureCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const client = new AzureOpenAI({
      endpoint: endpoint,
      apiVersion: apiVersion,
      azureADTokenProvider,
    });
    return client;
};

const client = getClient(); 

async function main(): Promise<void> {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Initialize messages with the first turn's user input 
    const messages: ChatCompletionMessageParam[] = [
      {
        role: "user",
        content: [
          { 
            type: "text", 
            text: "Describe in detail the spoken audio input." 
          },
          { 
            type: "input_audio", 
            input_audio: { 
              data: base64str, 
              format: "wav" 
            } 
          }
        ]
      }
    ];

    // Get the first turn's response 

    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: messages
    }); 

    console.log(response.choices[0]); 

    // Add a history message referencing the previous turn's audio by ID 
    messages.push({ 
        role: "assistant", 
        audio: response.choices[0].message.audio ? { id: response.choices[0].message.audio.id } : undefined
    });

    // Add a new user message for the second turn
    messages.push({ 
        role: "user", 
        content: [ 
            { 
              type: "text", 
              text: "Very concisely summarize the favorability." 
            } 
        ] 
    }); 

    // Send the follow-up request with the accumulated messages
    const followResponse = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        messages: messages
    });

    console.log(followResponse.choices[0].message.content); 
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Crie o tsconfig.json arquivo para transpilar o código TypeScript e copie o código a seguir para 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"]
}

Transpile de TypeScript para JavaScript.
```
tsc
```
Entre no Azure com o seguinte comando:
```
az login
```
Execute o código com o seguinte comando:
```
node multi-turn.js
```

Crie o multi-turn.ts arquivo com o seguinte código:

import { AzureOpenAI } from "openai/index.mjs";
import { promises as fs } from 'fs';
import { ChatCompletionMessageParam } from "openai/resources/index.mjs";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env["AZURE_OPENAI_ENDPOINT"] || "AZURE_OPENAI_ENDPOINT" as string;
const apiKey: string = process.env["AZURE_OPENAI_API_KEY"] || "AZURE_OPENAI_API_KEY";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
  endpoint, 
  apiKey, 
  apiVersion, 
  deployment 
});  

async function main(): Promise<void> {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Initialize messages with the first turn's user input 
    const messages: ChatCompletionMessageParam[] = [
      {
        role: "user",
        content: [
          { 
            type: "text", 
            text: "Describe in detail the spoken audio input." 
          },
          { 
            type: "input_audio", 
            input_audio: { 
              data: base64str, 
              format: "wav" 
            } 
          }
        ]
      }
    ];

    // Get the first turn's response 

    const response = await client.chat.completions.create({ 
      model: "gpt-4o-mini-audio-preview",
      modalities: ["text", "audio"], 
      audio: { voice: "alloy", format: "wav" }, 
      messages: messages
    }); 

    console.log(response.choices[0]); 

    // Add a history message referencing the previous turn's audio by ID 
    messages.push({ 
        role: "assistant", 
        audio: response.choices[0].message.audio ? { id: response.choices[0].message.audio.id } : undefined
    });

    // Add a new user message for the second turn
    messages.push({ 
        role: "user", 
        content: [ 
            { 
              type: "text", 
              text: "Very concisely summarize the favorability." 
            } 
        ] 
    }); 

    // Send the follow-up request with the accumulated messages
    const followResponse = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        messages: messages
    });

    console.log(followResponse.choices[0].message.content); 
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Crie o tsconfig.json arquivo para transpilar o código TypeScript e copie o código a seguir para 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"]
}

Transpile de TypeScript para JavaScript.
```
tsc
```
Execute o código com o seguinte comando:
```
node multi-turn.js
```

Aguarde alguns instantes para obter a resposta.

Saída para conclusão de bate-papo em vários turnos

O script gera uma transcrição do resumo da entrada de áudio falado. Em seguida, ele faz uma conclusão de bate-papo de várias voltas para resumir brevemente a entrada de áudio falado.

Recursos de limpeza

Se quiser limpar e remover um recurso do Azure OpenAI, você pode excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Saiba mais sobre os tipos de implantação do Azure OpenAI.
Saiba mais sobre as cotas e limites do Azure OpenAI.

Partilhar via

Guia de início rápido: introdução ao uso da geração de áudio do Azure OpenAI

Modelos suportados

Suporte de API

Implantar um modelo para geração de áudio

Use a geração de áudio GPT-4o

Modelos suportados

Suporte de API

Pré-requisitos

Pré-requisitos do Microsoft Entra ID

Configurar

Recuperar informações do recurso

Gerar áudio a partir da entrada de texto

Saída para geração de áudio a partir da entrada de texto

Gerar áudio e texto a partir da entrada de áudio

Saída para geração de áudio e texto a partir da entrada de áudio

Gere áudio e use finalizações de bate-papo em várias voltas

Saída para conclusão de bate-papo em vários turnos

Modelos suportados

Suporte de API

Pré-requisitos

Pré-requisitos do Microsoft Entra ID

Configurar

Recuperar informações do recurso

Gerar áudio a partir da entrada de texto

Saída para geração de áudio a partir da entrada de texto

Gerar áudio e texto a partir da entrada de áudio

Saída para geração de áudio e texto a partir da entrada de áudio

Gere áudio e use finalizações de bate-papo em várias voltas

Saída para conclusão de bate-papo em vários turnos

Modelos suportados

Suporte de API

Pré-requisitos

Pré-requisitos do Microsoft Entra ID

Configurar

Recuperar informações do recurso

Gerar áudio a partir da entrada de texto

Saída para geração de áudio a partir da entrada de texto

Gerar áudio e texto a partir da entrada de áudio

Saída para geração de áudio e texto a partir da entrada de áudio

Gere áudio e use finalizações de bate-papo em várias voltas

Saída para conclusão de bate-papo em vários turnos

Modelos suportados

Suporte de API

Pré-requisitos

Pré-requisitos do Microsoft Entra ID

Configurar

Recuperar informações do recurso

Gerar áudio a partir da entrada de texto

Saída para geração de áudio a partir da entrada de texto

Gerar áudio e texto a partir da entrada de áudio

Saída para geração de áudio e texto a partir da entrada de áudio

Gere áudio e use finalizações de bate-papo em várias voltas

Saída para conclusão de bate-papo em vários turnos

Recursos de limpeza

Conteúdos relacionados

Comentários

Recursos adicionais