BYOM (Bring Your Own Model) mit Voice Live API

Die Voice Live-API bietet BYOM-Funktionen (Bring Your Own Model), sodass Sie Ihre benutzerdefinierten Modelle in den VoIP-Interaktionsworkflow integrieren können. BYOM ist für die folgenden Szenarien nützlich:

• Feinabgestimmte Modelle: Verwenden Sie Ihre eigenen angepassten Azure OpenAI- oder Azure Foundry-Modelle
• Jedes Foundry-Modell, das nicht von Voice Live vorab bereitgestellt wurde: Verwenden Sie Modelle aus dem Foundry-Modellkatalog, z. B. Anthropic Claude, Grok, Fireworks Custom Weights oder eine Modell-Router-Bereitstellung
• Bereitgestellter Durchsatz: Verwenden Sie Ihre PTU-Bereitstellungen (Bereitgestellte Durchsatzeinheiten) für eine konsistente Leistung.
• Inhaltssicherheit: Anwenden angepasster Inhaltssicherheitskonfigurationen mit Ihrer LLM

Von Bedeutung

Sie können jedes modell, das in Ihrer Azure Foundry-Ressource bereitgestellt wird, in die Voice Live-API integrieren. Informationen zum Verwenden von Modellbereitstellungen aus einer anderen Foundry-Ressource finden Sie unter Ressourcenüberschreibungen.

Tipp

Wenn Sie Ihre eigene Modellbereitstellung mit Voice Live verwenden, empfehlen wir, die Inhaltsfilterkonfiguration auf asynchrone Filterung festzulegen, um die Latenz zu verringern. Inhaltsfiltereinstellungen können im Microsoft Foundry-Portal konfiguriert werden.

Authentifizierungseinstellungen

Wenn Sie die Microsoft Entra ID Authentifizierung mit der Voice Live-API im byom-azure-openai-chat-completion- oder byom-foundry-anthropic-messages-Modus verwenden, müssen Sie die richtigen Berechtigungen für Ihre Foundry-Ressource konfigurieren. Da Token bei langen Sitzungen ablaufen, benötigt die vom System zugewiesene verwaltete Identität der Foundry-Ressource Zugriff auf Bereitstellungsmodelle für diese BYOM-Modi.

Führen Sie die folgenden Azure CLI Befehle aus, um die erforderlichen Berechtigungen zu konfigurieren:

export subscription_id=<your-subscription-id>
export resource_group=<your-resource-group>
export foundry_resource=<your-foundry-resource>

# Enable system-assigned managed identity for the foundry resource
az cognitiveservices account identity assign --name ${foundry_resource} --resource-group ${resource_group} --subscription ${subscription_id}

# Get the system-assigned managed identity object ID
identity_principal_id=$(az cognitiveservices account show --name ${foundry_resource} --resource-group ${resource_group} --subscription ${subscription_id} --query "identity.principalId" -o tsv)

# Assign the Foundry User role to the system identity of the foundry resource
az role assignment create --assignee-object-id ${identity_principal_id} --role "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb" --scope /subscriptions/${subscription_id}/resourceGroups/${resource_group}/providers/Microsoft.CognitiveServices/accounts/${foundry_resource}

Hinweis

Da die Rollen "Foundry RBAC" kürzlich umbenannt wurden, verwenden Sie die Rollendefinitions-ID (GUID) anstelle des Rollennamens in Ihrem Code, um Probleme während des Umbenennungsrollouts zu vermeiden:

• Foundry-Benutzer: 53ca6127-db72-4b80-b1b0-d745d6d5456d
• Eigentümer der Gießerei: c883944f-8b7b-4483-af10-35834be79c4a
• Besitzer des Foundry-Kontos: e47c6f54-e4a2-4754-9501-8e0985b135e1
• Foundry Project Manager: eadc314b-1a2d-4efa-be10-5d325db5065e

Ressourcenübergreifende Authentifizierung

Wenn Sie Ressourcenüberschreibungen verwenden, ist die Authentifizierungseinrichtung unabhängig von Ihrer Authentifizierungsmethode (API-Schlüssel oder Microsoft Entra ID) obligatorisch. Sie müssen Berechtigungen sowohl für die Voice Live Foundry-Ressource als auch für die Modellgießereiressource konfigurieren. Führen Sie die folgenden Befehle aus, um die erforderlichen Berechtigungen zu konfigurieren:

export subscription_id_for_model=<your-subscription-id-for-model-resource>
export resource_group_for_model=<your-resource-group-for-model-resource>
export foundry_resource_for_model=<your-foundry-resource-for-model>

export subscription_id_for_voice_live=<your-subscription-id-for-voice-live-resource>
export resource_group_for_voice_live=<your-resource-group-for-voice-live-resource>
export foundry_resource_for_voice_live=<your-foundry-resource-for-voice-live>

# Enable system-assigned managed identity for the Voice Live Foundry resource
az cognitiveservices account identity assign \
    --name ${foundry_resource_for_voice_live} \
    --resource-group ${resource_group_for_voice_live} \
    --subscription ${subscription_id_for_voice_live}

# Get the system-assigned managed identity object ID
# for the Voice Live resource
identity_principal_id=$(az cognitiveservices account show \
    --name ${foundry_resource_for_voice_live} \
    --resource-group ${resource_group_for_voice_live} \
    --subscription ${subscription_id_for_voice_live} \
    --query "identity.principalId" -o tsv)

# Assign the Foundry User role to the Voice Live resource's
# system identity on the model Foundry resource
az role assignment create \
    --assignee-object-id ${identity_principal_id} \
    --role "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb" \
    --scope /subscriptions/${subscription_id_for_model}/resourceGroups/${resource_group_for_model}/providers/Microsoft.CognitiveServices/accounts/${foundry_resource_for_model}

Auswählen des BYOM-Integrationsmodus

Die Voice Live-API unterstützt drei BYOM-Integrationsmodi:

Modus	Description	Beispielmodelle
byom-azure-openai-realtime	Azure OpenAI-Echtzeitmodelle für Streaming-Sprachinteraktionen	gpt-realtime, gpt-realtime-mini
byom-azure-openai-chat-completion	Azure OpenAI-Chatabschlussmodelle für textbasierte Interaktionen. Gilt auch für andere Foundry-Modelle	gpt-5.4, grok-4
byom-foundry-anthropic-messages	In Azure Foundry bereitgestellte anthropische Claude-Modelle mithilfe der Nachrichten-API (Vorschau)	claude-sonnet-4.6, claude-haiku-4.5

Hinweis

Der byom-foundry-anthropic-messages Modus befindet sich derzeit in der Vorschauphase. Vorschaufeatures können geändert werden und haben möglicherweise eine eingeschränkte Verfügbarkeit.

Integrieren von BYOM

REST-API

Aktualisieren Sie die Endpunkt-URL in Ihrem API-Aufruf, um Ihre BYOM-Konfiguration einzuschließen:

wss://<your-foundry-resource>.services.ai.azure.com/voice-live/realtime?api-version=2026-04-10&profile=<your-byom-mode>&model=<your-model-deployment>

Rufen Sie den <your-model-deployment> Wert aus dem Foundry-Portal ab. Er entspricht dem Namen, den Sie dem Modell zur Bereitstellungszeit gegeben haben.

Um beispielsweise ein in Azure Foundry bereitgestelltes Anthropic Claude-Modell zu verwenden:

wss://<your-foundry-resource>.services.ai.azure.com/voice-live/realtime?api-version=2026-04-10&profile=byom-foundry-anthropic-messages&model=<your-claude-deployment-name>

Um eine Modellbereitstellung aus einer anderen Foundry-Ressource zu verwenden, fügen Sie den foundry-resource-override Parameter hinzu:

wss://<your-foundry-resource>.services.ai.azure.com/voice-live/realtime?api-version=2026-04-10&profile=<your-byom-mode>&model=<your-model-deployment>&foundry-resource-override=<foundry-resource>

Der <foundry-resource> Wert ist der Ressourcenname ohne das Domänensuffix. Wenn z. B. der Ressourcenendpunkt "Foundry" https://my-foundry-resource.services.ai.azure.com lautet, dann verwenden Sie my-foundry-resource.

Python SDK

Reference-Dokumentation | Package (PyPi) | Additional samples on GitHub

Verwenden Sie den Schnellstartcode Python SDK, um eine Sprachunterhaltung zu starten, und nehmen Sie die folgenden Änderungen vor, um BYOM zu aktivieren:

1. Fügen Sie in der parse_arguments() Funktion ein neues Argument für den BYOM-Profiltyp hinzu:

   parser.add_argument(
        "--byom",
        help="BYOM (Bring Your Own Model) profile type",
        type=str,
        choices=["byom-azure-openai-realtime", "byom-azure-openai-chat-completion", "byom-foundry-anthropic-messages"],
        default=os.environ.get("VOICELIVE_BYOM_MODE", "byom-azure-openai-chat-completion"),
    )
   parser.add_argument(
        "--foundry-resource-override",
        help="Override the Foundry resource for cross-resource BYOM",
        type=str,
        default=os.environ.get("VOICELIVE_FOUNDRY_RESOURCE_OVERRIDE"),
    )
   

2. Fügen Sie in der main() Funktion das byom Feld beim Erstellen des Sprachassistenten hinzu:

   # Create and start voice assistant
   assistant = BasicVoiceAssistant(
   ...
   byom=args.byom,
   foundry_resource_override=args.foundry_resource_override,
   ...
   )
   

3. Fügen Sie in der BasicVoiceAssistant Klasse die Felder byom und foundry_resource_override hinzu:

   class BasicVoiceAssistant:
   """Basic voice assistant implementing the VoiceLive SDK patterns."""
   
   def __init__(
       self,
       endpoint: str,
       credential: Union[AzureKeyCredential, TokenCredential],
       model: str,
       voice: str,
       instructions: str,
       byom: Literal["byom-azure-openai-realtime", "byom-azure-openai-chat-completion", "byom-foundry-anthropic-messages"] | None = None,
       foundry_resource_override: str | None = None
   ):
   
       self.endpoint = endpoint
       self.credential = credential
       self.model = model
       self.voice = voice
       self.instructions = instructions
       self.connection: Optional["VoiceLiveConnection"] = None
       self.audio_processor: Optional[AudioProcessor] = None
       self.session_ready = False
       self.conversation_started = False
       self.byom = byom
       self.foundry_resource_override = foundry_resource_override
   
   async def start(self):
       """Start the voice assistant session."""
       try:
           logger.info(f"Connecting to VoiceLive API with model {self.model}")
   
           # Connect to VoiceLive WebSocket API
           query_params = {"profile": self.byom} if self.byom else None
           if query_params and self.foundry_resource_override:
               query_params["foundry-resource-override"] = self.foundry_resource_override
   
           async with connect(
               endpoint=self.endpoint,
               credential=self.credential,
               model=self.model,
               query=query_params
           ) as connection:
           ...
   

4. Wenn Sie den Code ausführen, geben Sie das --byom Argument zusammen mit dem --model Argument an, um das BYOM-Profil und die Modellbereitstellung anzugeben, die Sie verwenden möchten. Beispiel:

   python voice-live-quickstart.py --byom "byom-azure-openai-chat-completion" --model "your-model-name"
   

   So verwenden Sie ein anthropisches Claude-Modell:

   python voice-live-quickstart.py --byom "byom-foundry-anthropic-messages" --model "your-claude-deployment-name"
   

   Um ein Modell aus einer anderen Foundry-Ressource zu verwenden, fügen Sie das --foundry-resource-override Argument hinzu:

   python voice-live-quickstart.py --byom "byom-azure-openai-chat-completion" --model "your-model-name" --foundry-resource-override "my-foundry-resource"
   

C# SDK

Reference-Dokumentation | Package (NuGet) | Additional samples on GitHub

Verwenden Sie den C# VoiceLive SDK-Schnellstartcode , um eine Sprachunterhaltung zu starten, und nehmen Sie die folgenden Änderungen vor, um BYOM zu aktivieren:

1. Fügen Sie am Anfang der Datei die Anweisungen mit System.Web und System.Runtime.InteropServices ein:

   using System.Web;
   using System.Runtime.InteropServices;
   

2. Ersetzen Sie sie in der CreateRootCommand Funktion durch den folgenden Code, um "byomOption" hinzuzufügen:

   private static RootCommand CreateRootCommand()
   {
       var rootCommand = new RootCommand("Basic Voice Assistant using Azure VoiceLive SDK");
   
       var apiKeyOption = new Option<string?>(
           "--api-key",
           "Azure VoiceLive API key. If not provided, will use AZURE_VOICELIVE_API_KEY environment variable.");
   
       var endpointOption = new Option<string>(
           "--endpoint",
           () => "wss://api.voicelive.com/v1",
           "Azure VoiceLive endpoint");
   
       var modelOption = new Option<string>(
           "--model",
           () => "gpt-4o",
           "VoiceLive model to use");
   
       var byomOption = new Option<string>(
           "--byom",
           () => "byom-azure-openai-chat-completion",
           "BYOM integration mode. Supported modes: byom-azure-openai-realtime, byom-azure-openai-chat-completion, byom-foundry-anthropic-messages");
   
       var foundryResourceOverrideOption = new Option<string?>(
           "--foundry-resource-override",
           "Override the Foundry resource for cross-resource BYOM");
   
       var voiceOption = new Option<string>(
           "--voice",
           () => "en-US-AvaNeural",
           "Voice to use for the assistant");
   
       var instructionsOption = new Option<string>(
           "--instructions",
           () => "You are a helpful AI assistant. Respond naturally and conversationally. Keep your responses concise but engaging. Always start the conversation in English.",
           "System instructions for the AI assistant");
   
       var useTokenCredentialOption = new Option<bool>(
           "--use-token-credential",
           "Use Azure token credential instead of API key");
   
       var verboseOption = new Option<bool>(
           "--verbose",
           "Enable verbose logging");
   
       rootCommand.AddOption(apiKeyOption);
       rootCommand.AddOption(endpointOption);
       rootCommand.AddOption(modelOption);
       rootCommand.AddOption(byomOption);
       rootCommand.AddOption(foundryResourceOverrideOption);
       rootCommand.AddOption(voiceOption);
       rootCommand.AddOption(instructionsOption);
       rootCommand.AddOption(useTokenCredentialOption);
       rootCommand.AddOption(verboseOption);
   
       rootCommand.SetHandler(async (
           string? apiKey,
           string endpoint,
           string model,
           string byom,
           string? foundryResourceOverride,
           string voice,
           string instructions,
           bool useTokenCredential,
           bool verbose) =>
       {
           await RunVoiceAssistantAsync(apiKey, endpoint, model, byom, foundryResourceOverride, voice, instructions, useTokenCredential, verbose).ConfigureAwait(false);
       },
       apiKeyOption,
       endpointOption,
       modelOption,
       byomOption,
       foundryResourceOverrideOption,
       voiceOption,
       instructionsOption,
       useTokenCredentialOption,
       verboseOption);
   
       return rootCommand;
   }
   

3. Fügen Sie in der Funktion RunVoiceAssistantAsyncden Parameter "byom" und das Konfigurationssetup hinzu:

   private static async Task RunVoiceAssistantAsync(
       string? apiKey,
       string endpoint,
       string model,
       string byom,
       string? foundryResourceOverride,
       string voice,
       string instructions,
       bool useTokenCredential,
       bool verbose)
   {
       // Setup configuration
       var configuration = new ConfigurationBuilder()
           .AddJsonFile("appsettings.json", optional: true)
           .AddEnvironmentVariables()
           .Build();
   
       // Override with command line values if provided
       apiKey ??= configuration["VoiceLive:ApiKey"] ?? Environment.GetEnvironmentVariable("AZURE_VOICELIVE_API_KEY");
       endpoint = configuration["VoiceLive:Endpoint"] ?? endpoint;
       model = configuration["VoiceLive:Model"] ?? model;
       byom = configuration["VoiceLive:Byom"] ?? byom;
       foundryResourceOverride ??= configuration["VoiceLive:FoundryResourceOverride"];
       voice = configuration["VoiceLive:Voice"] ?? voice;
       instructions = configuration["VoiceLive:Instructions"] ?? instructions;
   ...  
   

4. Fügen Sie in der Funktion RunVoiceAssistantAsync den BYOM-Profilparameter an die Endpunkt-URL an, bevor Sie den Client erstellen:

   try
   {
       // Append BYOM profile parameter to the endpoint URL if provided
       if (!string.IsNullOrEmpty(byom))
       {
           var uriBuilder = new UriBuilder(endpoint);
           var query = HttpUtility.ParseQueryString(uriBuilder.Query);
           query["profile"] = byom;
           if (!string.IsNullOrEmpty(foundryResourceOverride))
           {
               query["foundry-resource-override"] = foundryResourceOverride;
           }
           uriBuilder.Query = query.ToString();
           endpoint = uriBuilder.ToString();
           logger.LogInformation("BYOM profile parameter added to endpoint: profile={Profile}", byom);
       }
   
       // Create client with appropriate credential
       VoiceLiveClient client;
       var endpointUri = new Uri(endpoint);
       if (useTokenCredential)
       {
           var tokenCredential = new DefaultAzureCredential();
           client = new VoiceLiveClient(endpointUri, tokenCredential, new VoiceLiveClientOptions());
           logger.LogInformation("Using Azure token credential");
       }
       else
       {
           var keyCredential = new Azure.AzureKeyCredential(apiKey!);
           client = new VoiceLiveClient(endpointUri, keyCredential, new VoiceLiveClientOptions());
           logger.LogInformation("Using API key credential");
       }
   ...
   

5. Fügen Sie in der Funktion RunVoiceAssistantAsync"byom" zum Setup des Sprachassistenten hinzu:

   ...
   // Create and start voice assistant
   using var assistant = new BasicVoiceAssistant(
       client,
       model,
       byom,
       voice,
       instructions,
       loggerFactory);
   ...
   

6. Fügen Sie in der Klasse BasicVoiceAssistantdas _byom Feld hinzu, und aktualisieren Sie den Konstruktor:

   public class BasicVoiceAssistant : IDisposable
   {
       private readonly VoiceLiveClient _client;
   
       private readonly string _model;
       private readonly string _byom;
       private readonly string _voice;
       private readonly string _instructions;
       ...
   
       public BasicVoiceAssistant(
           VoiceLiveClient client,
           string model,
           string byom,
           string voice,
           string instructions,
           ILoggerFactory loggerFactory)
       {
           _client = client ?? throw new ArgumentNullException(nameof(client));
           _model = model ?? throw new ArgumentNullException(nameof(model));
           _byom = byom ?? throw new ArgumentNullException(nameof(byom));
           _voice = voice ?? throw new ArgumentNullException(nameof(voice));
           _instructions = instructions ?? throw new ArgumentNullException(nameof(instructions));
           _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
           _logger = loggerFactory.CreateLogger<BasicVoiceAssistant>();
       }
   ...
   

7. Aktualisieren Sie in der Funktion „StartAsync“ den Protokollierungs- und Sitzungsstartaufruf (BYOM-Profil befindet sich bereits im Endpunkt):

   public async Task StartAsync(CancellationToken cancellationToken = default)
   {
       try
       {
           _logger.LogInformation("Connecting to VoiceLive API with model {Model} and BYOM mode {Byom}", _model, _byom);
   
           // Start VoiceLive session (BYOM profile is already in the client endpoint)
           _session = await _client.StartSessionAsync(_model, cancellationToken).ConfigureAwait(false);
   ...
   

8. Wenn Sie den Code ausführen, geben Sie das --byom Argument zusammen mit dem --model Argument an, um das BYOM-Profil und die Modellbereitstellung anzugeben, die Sie verwenden möchten. Beispiel:

   dotnet run --byom "byom-azure-openai-chat-completion" --model "your-model-name"
   

   So verwenden Sie ein anthropisches Claude-Modell:

   dotnet run --byom "byom-foundry-anthropic-messages" --model "your-claude-deployment-name"
   

   Um ein Modell aus einer anderen Foundry-Ressource zu verwenden, fügen Sie das --foundry-resource-override Argument hinzu:

   dotnet run --byom "byom-azure-openai-chat-completion" --model "your-model-name" --foundry-resource-override "my-foundry-resource"
   
   

Java SDK

Referenzdokumentation | Package (Maven) | Weitere Beispiele auf GitHub

Verwenden Sie den Schnellstartcode Java SDK, um eine Sprachunterhaltung zu starten, und nehmen Sie die folgenden Änderungen vor, um BYOM zu aktivieren:

1. Fügen Sie die Importanweisungen java.net.URI und java.net.URISyntaxException oben in der Datei hinzu.

   import java.net.URI;
   import java.net.URISyntaxException;
   

2. Fügen Sie in der Config Klasse ein byom Feld hinzu, und analysieren Sie das --byom Befehlszeilenargument:

   private static class Config {
       String endpoint;
       String apiKey;
       String model = DEFAULT_MODEL;
       String voice = DEFAULT_VOICE;
       String instructions = DEFAULT_INSTRUCTIONS;
       String byom = null;
       boolean useTokenCredential = false;
   
       static Config load(String[] args) {
           Config config = new Config();
   
           // 1. Load from application.properties first
           Properties props = loadProperties();
           if (props != null) {
               config.endpoint = props.getProperty("azure.voicelive.endpoint");
               config.apiKey = props.getProperty("azure.voicelive.api-key");
               config.model = props.getProperty("azure.voicelive.model", DEFAULT_MODEL);
               config.voice = props.getProperty("azure.voicelive.voice", DEFAULT_VOICE);
               config.instructions = props.getProperty("azure.voicelive.instructions", DEFAULT_INSTRUCTIONS);
               config.byom = props.getProperty("azure.voicelive.byom");
           }
   
           // 2. Override with environment variables if present
           if (System.getenv(ENV_ENDPOINT) != null) {
               config.endpoint = System.getenv(ENV_ENDPOINT);
           }
           if (System.getenv(ENV_API_KEY) != null) {
               config.apiKey = System.getenv(ENV_API_KEY);
           }
           if (System.getenv("AZURE_VOICELIVE_MODEL") != null) {
               config.model = System.getenv("AZURE_VOICELIVE_MODEL");
           }
           if (System.getenv("AZURE_VOICELIVE_VOICE") != null) {
               config.voice = System.getenv("AZURE_VOICELIVE_VOICE");
           }
           if (System.getenv("AZURE_VOICELIVE_INSTRUCTIONS") != null) {
               config.instructions = System.getenv("AZURE_VOICELIVE_INSTRUCTIONS");
           }
           if (System.getenv("VOICELIVE_BYOM_MODE") != null) {
               config.byom = System.getenv("VOICELIVE_BYOM_MODE");
           }
   
           // 3. Parse command line arguments (highest priority)
           for (int i = 0; i < args.length; i++) {
               switch (args[i]) {
                   case "--endpoint":
                       if (i + 1 < args.length) config.endpoint = args[++i];
                       break;
                   case "--api-key":
                       if (i + 1 < args.length) config.apiKey = args[++i];
                       break;
                   case "--model":
                       if (i + 1 < args.length) config.model = args[++i];
                       break;
                   case "--voice":
                       if (i + 1 < args.length) config.voice = args[++i];
                       break;
                   case "--instructions":
                       if (i + 1 < args.length) config.instructions = args[++i];
                       break;
                   case "--byom":
                       if (i + 1 < args.length) config.byom = args[++i];
                       break;
                   case "--use-token-credential":
                       config.useTokenCredential = true;
                       break;
               }
           }
   
           return config;
       }
   }
   

3. Fügen Sie in der runVoiceAssistantWithClient Methode den BYOM-Profilabfrageparameter an die Endpunkt-URL an, bevor Sie den Client erstellen. Ersetzen Sie die beiden runVoiceAssistant Überladungen durch Implementierungen, die die Modifizierung von Endpunkten handhaben:

   private static void runVoiceAssistant(Config config, KeyCredential credential) {
       String endpoint = appendByomProfile(config.endpoint, config.byom);
       System.out.println("Initializing VoiceLive client:");
       System.out.println("   Endpoint: " + endpoint);
       if (config.byom != null) {
           System.out.println("   BYOM profile: " + config.byom);
       }
   
       VoiceLiveAsyncClient client = new VoiceLiveClientBuilder()
           .endpoint(endpoint)
           .credential(credential)
           .serviceVersion(VoiceLiveServiceVersion.V2025_10_01)
           .buildAsyncClient();
   
       runVoiceAssistantWithClient(client, config);
   }
   
   private static void runVoiceAssistant(Config config, TokenCredential credential) {
       String endpoint = appendByomProfile(config.endpoint, config.byom);
       System.out.println("Initializing VoiceLive client:");
       System.out.println("   Endpoint: " + endpoint);
       if (config.byom != null) {
           System.out.println("   BYOM profile: " + config.byom);
       }
   
       VoiceLiveAsyncClient client = new VoiceLiveClientBuilder()
           .endpoint(endpoint)
           .credential(credential)
           .serviceVersion(VoiceLiveServiceVersion.V2025_10_01)
           .buildAsyncClient();
   
       runVoiceAssistantWithClient(client, config);
   }
   

4. Fügen Sie die appendByomProfile Hilfsmethode hinzu, die das BYOM-Profil als Abfrageparameter an die Endpunkt-URL anfüge:

   private static String appendByomProfile(String endpoint, String byom) {
       if (byom == null || byom.isEmpty()) {
           return endpoint;
       }
       try {
           URI uri = new URI(endpoint);
           String existingQuery = uri.getQuery();
           String newQuery = (existingQuery != null && !existingQuery.isEmpty())
               ? existingQuery + "&profile=" + byom
               : "profile=" + byom;
           URI newUri = new URI(
               uri.getScheme(), uri.getAuthority(), uri.getPath(),
               newQuery, uri.getFragment());
           return newUri.toString();
       } catch (URISyntaxException e) {
           System.err.println("Failed to append BYOM profile to endpoint: "
               + e.getMessage());
           return endpoint;
       }
   }
   

5. Wenn Sie den Code ausführen, geben Sie das --byom Argument zusammen mit dem --model Argument an, um das BYOM-Profil und die Modellbereitstellung anzugeben, die Sie verwenden möchten. Beispiel:

   mvn exec:java -Dexec.args="--byom byom-azure-openai-chat-completion --model your-model-name"
   

JavaScript SDK

Reference-Dokumentation | Package (npm) | Zusätzliche Beispiele auf GitHub

Verwenden Sie den JavaScript SDK-Schnellstartcode , um eine Sprachunterhaltung zu starten, und nehmen Sie die folgenden Änderungen vor, um BYOM zu aktivieren:

1. Fügen Sie in der parseArguments() Funktion ein neues --byom Argument hinzu:

   const parsed = {
     ...
     byom: process.env.VOICELIVE_BYOM_MODE ?? undefined,
     ...
   };
   
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     switch (arg) {
       ...
       case "--byom":
         parsed.byom = argv[++i];
         break;
       ...
     }
   }
   

2. Übergeben Sie in der main() Funktion den byom Wert beim Erstellen des Sprachassistenten:

   const assistant = new BasicModelVoiceAssistant({
     ...
     byom: args.byom,
     ...
   });
   

3. Fügen Sie in der BasicModelVoiceAssistant Klasse das byom Feld im Konstruktor hinzu:

   class BasicModelVoiceAssistant {
     constructor(options) {
       ...
       this.byom = options.byom;
       ...
     }
   ...
   

4. Fügen Sie in der start() Methode den BYOM-Profilabfrageparameter an die Endpunkt-URL an, bevor Sie den Client erstellen:

   async start() {
     let endpoint = this.endpoint;
   
     // Append BYOM profile query parameter if provided
     if (this.byom) {
       const url = new URL(endpoint);
       url.searchParams.set("profile", this.byom);
       endpoint = url.toString();
       console.log(`[init] BYOM profile added to endpoint: profile=${this.byom}`);
     }
   
     const client = new VoiceLiveClient(endpoint, this.credential);
     const session = client.createSession({ model: this.model });
     this._session = session;
     ...
   

5. Wenn Sie den Code ausführen, geben Sie das --byom Argument zusammen mit dem --model Argument an, um das BYOM-Profil und die Modellbereitstellung anzugeben, die Sie verwenden möchten. Beispiel:

   node model-quickstart.js --byom "byom-azure-openai-chat-completion" --model "your-model-name"
   

Hinweis

Wenn Sie den byom-foundry-anthropic-messages Modus verwenden, enthält das usage Feld in response.done Ereignissen nur die Verwendung von Audiotoken (für die Spracherkennung und text-zu-Sprache). Die VERWENDUNG von LLM-Token aus dem Anthropic-Modell wird separat in den Antwortmetadaten gemeldet.

Ressourcenüberschreibungen

Standardmäßig verwendet die Voice Live-API LLM-Bereitstellungen in derselben Foundry-Ressource wie der Voice Live-Dienst. Wenn sich Ihre Modellbereitstellungen in einer anderen Foundry-Ressource befinden, geben Sie den foundry-resource-override Abfrageparameter an, um die API an die richtige Ressource umzuleiten. Dies unterstützt regionsübergreifende Szenarien, in denen sich der Voice Live-Dienst und die Modellbereitstellungen in verschiedenen Regionen befinden.

Der foundry-resource-override Wert ist der Ressourcenname ohne das Domänensuffix. Wenn beispielsweise der Ressourcenendpunkt "Foundry" lautet https://my-foundry-resource.services.ai.azure.com, verwenden Sie my-foundry-resource.

Details zur Implementierung finden Sie auf jeder Registerkarte im Integrieren von BYOM-Abschnitt.

Von Bedeutung

Wenn Sie Ressourcenüberschreibungen verwenden, müssen Sie cross-resource authentication unabhängig von Ihrer Authentifizierungsmethode (API-Schlüssel oder Microsoft Entra ID) konfigurieren.

Verwandte Inhalte

• Probieren Sie den Voice Live-Schnellstart aus
• Weitere Informationen zur Verwendung der Voice Live-API
• Siehe Die Voice Live-API-Referenz