Migrieren von Azure AI Inference SDK zu OpenAI SDK

Dieser Artikel enthält Anleitungen zum Migrieren Ihrer Anwendungen vom Azure AI Inference SDK zum OpenAI SDK. Das OpenAI SDK bietet umfassendere Kompatibilität, Zugriff auf die neuesten OpenAI-Features und vereinfachten Code mit einheitlichen Mustern über Azure OpenAI- und Foundry-Modelle hinweg.

Hinweis

Das OpenAI SDK bezieht sich auf die Clientbibliotheken (z. B. das Python openai-Paket oder JavaScript-openai npm-Paket), die eine Verbindung mit OpenAI v1-API-Endpunkten herstellen. Diese SDKs weisen eine eigene Versionsverwaltung getrennt von der API-Version auf , z. B. ist das Go OpenAI SDK derzeit auf v3, stellt jedoch weiterhin eine Verbindung mit den OpenAI v1-API-Endpunkten her, die sich im URL-Pfad befinden /openai/v1/ .

Vorteile der Migration

Die Migration zum OpenAI SDK bietet mehrere Vorteile:

Breitere Modellunterstützung: Funktioniert mit Azure OpenAI in Foundry-Modellen sowie anderen Foundry-Modellen von Anbietern wie DeepSeek und Grok.
Unified API: Verwendet die gleichen SDK-Bibliotheken und -Clients sowohl für OpenAI- als auch für Azure OpenAI-Endpunkte.
Latest-Features: Zugriff auf die neuesten OpenAI-Features, ohne auf Azure spezifische Updates warten zu müssen
Vereinfachte Authentifizierung: Integrierte Unterstützung für API-Schlüssel und Microsoft Entra ID Authentifizierung
Implizite API-Versionsverwaltung: Die v1-API beseitigt die Notwendigkeit, häufig Parameter zu aktualisieren api-version

Wichtige Unterschiede

Die folgende Tabelle zeigt die wichtigsten Unterschiede zwischen den beiden SDKs:

Aspekt	Azure KI-Rückschluss-SDK	OpenAI SDK
Clientklasse	`ChatCompletionsClient`	`OpenAI`
Endpunktformat	`https://<resource>.services.ai.azure.com/models`	`https://<resource>.openai.azure.com/openai/v1/`
API-Version	Erforderlich im URL oder Parameter	Nicht erforderlich (verwendet v1-API)
Modellparameter	Optional (für Multimodellendpunkte)	Erforderlich (Bereitstellungsname)
Authentifizierung	nur Azure Anmeldeinformationen	API-Schlüssel oder Azure Anmeldeinformationen

Konfiguration

Installieren Sie das OpenAI SDK:

pip install openai

Installieren Sie für Microsoft Entra ID Authentifizierung auch Folgendes:

pip install azure-identity

Mit API-Schlüsselauthentifizierung:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://<resource>.openai.azure.com/openai/v1/",
)

import os
from azure.ai.inference import ChatCompletionsClient
from azure.core.credentials import AzureKeyCredential

client = ChatCompletionsClient(
    endpoint="https://<resource>.services.ai.azure.com/models",
    credential=AzureKeyCredential(os.environ["AZURE_INFERENCE_CREDENTIAL"]),
)

Mit Microsoft Entra ID Authentifizierung:

OpenAI SDK
Azure AI Inference SDK

from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

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

client = OpenAI(
    base_url="https://<resource>.openai.azure.com/openai/v1/",
    api_key=token_provider,
)

from azure.ai.inference import ChatCompletionsClient
from azure.identity import DefaultAzureCredential

client = ChatCompletionsClient(
    endpoint="https://<resource>.services.ai.azure.com/models",
    credential=DefaultAzureCredential(),
    credential_scopes=["https://cognitiveservices.azure.com/.default"],
)

Chatvervollständigung

OpenAI SDK
Azure AI Inference SDK

response = client.chat.completions.create(
    model="DeepSeek-V3.1",  # Required: your deployment name
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "How many languages are in the world?"}
    ]
)

print(response.choices[0].message.content)

Die Ausgabe lautet wie folgt:

Response: As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.

from azure.ai.inference.models import SystemMessage, UserMessage

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    model="DeepSeek-V3.1"  # Optional for single-model endpoints
)

print(response.choices[0].message.content)

Die Ausgabe lautet wie folgt:

Response: <think>Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...</think>As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.

Streaming

OpenAI SDK
Azure AI Inference SDK

stream = client.chat.completions.create(
    model="DeepSeek-V3.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a poem about Azure."}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

from azure.ai.inference.models import SystemMessage, UserMessage

response = client.complete(
    stream=True,
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="Write a poem about Azure."),
    ],
    model="DeepSeek-V3.1"
)

for update in response:
    if update.choices:
        print(update.choices[0].delta.content or "", end="")

Responses

Die Antwort-API ist die zustandsbehaftete Schnittstelle von OpenAI, die ein strukturiertes output Array zurückgibt, das Nachrichten-, Toolaufrufe und Begründungselemente enthält.

OpenAI SDK
Azure AI Inference SDK

response = client.responses.create(
    model="DeepSeek-V3.1",  # Required: your deployment name
    input="How many languages are in the world?",
    max_output_tokens=2000,
)

print(response.output_text)

Argumentation

Hinweis

Diese Informationen zu Reasoning-Inhalten gelten nicht für Azure OpenAI-Modelle. Azure OpenAI-Begründungsmodelle verwenden die Funktion reasoning summaries.

Einige Begründungsmodelle, z. B. DeepSeek-R1, generieren Fertigstellungen und enthalten die Gründe dafür. Die Antwort-API zeigt dies als strukturiertes reasoning Ausgabeelement an, das summary[].text das Denken des Modells zusammen mit der endgültigen Antwort enthält.

OpenAI SDK
Azure AI Inference SDK

response = client.responses.create(
    model="DeepSeek-R1-0528",  # Required: your deployment name
    input="How many languages are in the world?",
    max_output_tokens=2000,
)

# Walk response.output for items of type "reasoning" and join summary[].text.
parts = []
for item in getattr(response, "output", None) or []:
    if getattr(item, "type", None) != "reasoning":
        continue
    for s in getattr(item, "summary", None) or []:
        text = getattr(s, "text", None)
        if text:
            parts.append(text)
reasoning_summary = "\n".join(parts).strip()

print("Thinking:", reasoning_summary)
print("Answer:", response.output_text)

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...
Answer: There are approximately 7,000 languages spoken around the world today.

Hinweis

Bekanntes Problem: Bei Foundry-Modellen (Nicht-Azure OpenAI-Modelle) wie DeepSeek-R1-0528 wird der Text der Begründungszusammenfassung für jedes reasoning Ausgabeelement zwar zuverlässig ausgefüllt, doch die Anzahl der Token für die Begründung in den Nutzungsdetails der Antwort (reasoning_tokens im Datenverkehr) wird derzeit mit 0 angegeben, selbst wenn der Text der Zusammenfassung vorhanden ist. Verlassen Sie sich bei der Verwendung von Foundry-Modellen nicht auf die Anzahl der Begründungs-Token für die Abrechnung oder Kontingentberechnung. Diese Einschränkung gilt nicht für Azure OpenAI in Foundry Models.

Das Azure AI Inference SDK macht die Antwort-API nicht verfügbar. Um Inhalte zum schlussfolgernden Denken zu erhalten, rufen Sie stattdessen die Chat-Completions-API auf. Die Begründung ist im Nachrichteninhalt enthalten, der von den Tags <think> und </think> umschlossen wird und den Sie mit einem Regex-Abgleich extrahieren können.

import re
from azure.ai.inference.models import SystemMessage, UserMessage

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    model="DeepSeek-R1-0528"  # Optional for single-model endpoints
)

content = response.choices[0].message.content
match = re.match(r"<think>(.*?)</think>(.*)", content, re.DOTALL)
if match:
    print("Thinking:", match.group(1).strip())
    print("Answer: ", match.group(2).strip())
else:
    print("Response:", content)

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...
Answer:  There are approximately 7,000 languages spoken around the world today.

Wenn Sie mehrteilige Unterhaltung führen, vermeiden Sie es, Begründungsinhalte im Chatverlauf zu senden, da diese tendenziell lange Erklärungen erzeugen.

Einbettungen

OpenAI SDK
Azure AI Inference SDK

from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

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

client = OpenAI(
    base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key = token_provider,
)

response = client.embeddings.create(
    input = "How do I use Python in VS Code?",
    model = "text-embedding-3-large" // Use the name of your deployment
)
print(response.data[0].embedding)

from azure.ai.inference import EmbeddingsClient
from azure.core.credentials import AzureKeyCredential

client = EmbeddingsClient(
    endpoint="https://<resource>.services.ai.azure.com/models",
    credential=AzureKeyCredential(os.environ["AZURE_INFERENCE_CREDENTIAL"]),
)

response = client.embed(
    input=["Your text string goes here"],
    model="text-embedding-3-small"
)

embedding = response.data[0].embedding

Konfiguration

Installieren Sie das OpenAI SDK:

dotnet add package OpenAI

Installieren Sie für Microsoft Entra ID Authentifizierung auch Folgendes:

dotnet add package Azure.Identity

Clientkonfiguration

Mit API-Schlüsselauthentifizierung:

OpenAI SDK
Azure AI Inference SDK

using OpenAI;
using OpenAI.Chat;
using System.ClientModel;

ChatClient client = new(
    model: "gpt-4o-mini", // Your deployment name
    credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")),
    options: new OpenAIClientOptions() { 
        Endpoint = new Uri("https://<resource>.openai.azure.com/openai/v1/")
    }
);

using Azure;
using Azure.AI.Inference;

ChatCompletionsClient client = new ChatCompletionsClient(
    new Uri("https://<resource>.services.ai.azure.com/models"),
    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);

Mit Microsoft Entra ID Authentifizierung:

OpenAI SDK
Azure AI Inference SDK

using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default"
);

ChatClient client = new(
    model: "gpt-4o-mini", // Your deployment name
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions() {
        Endpoint = new Uri("https://<resource>.openai.azure.com/openai/v1/")
    }
);

using Azure;
using Azure.Identity;
using Azure.AI.Inference;

ChatCompletionsClient client = new ChatCompletionsClient(
    new Uri("https://<resource>.services.ai.azure.com/models"),
    new DefaultAzureCredential()
);

Chatvervollständigung

OpenAI SDK
Azure AI Inference SDK

using OpenAI.Chat;

ChatCompletion completion = client.CompleteChat(
    new SystemChatMessage("You are a helpful assistant."),
    new UserChatMessage("What is Azure AI?")
);

Console.WriteLine(completion.Content[0].Text);

using Azure.AI.Inference;

ChatCompletionsOptions requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
    Model = "DeepSeek-V3.1", // Optional for single-model endpoints
};

Response<ChatCompletions> response = client.Complete(requestOptions);
Console.WriteLine(response.Value.Choices[0].Message.Content);

Streaming

OpenAI SDK
Azure AI Inference SDK

using OpenAI.Chat;

CollectionResult<StreamingChatCompletionUpdate> updates = client.CompleteChatStreaming(
    new SystemChatMessage("You are a helpful assistant."),
    new UserChatMessage("Write a poem about Azure.")
);

foreach (StreamingChatCompletionUpdate update in updates)
{
    foreach (ChatMessageContentPart part in update.ContentUpdate)
    {
        Console.Write(part.Text);
    }
}

using Azure.AI.Inference;

ChatCompletionsOptions requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("Write a poem about Azure.")
    },
    Model = "gpt-4o-mini",
};

StreamingResponse<StreamingChatCompletionsUpdate> response = client.CompleteStreaming(requestOptions);

await foreach (StreamingChatCompletionsUpdate update in response)
{
    if (update.ContentUpdate != null)
    {
        Console.Write(update.ContentUpdate);
    }
}

Responses

Die Antwort-API ist die zustandsbehaftete Schnittstelle von OpenAI, die ein strukturiertes output Array zurückgibt, das Nachrichten-, Toolaufrufe und Begründungselemente enthält.

OpenAI SDK
Azure AI Inference SDK

using OpenAI.Responses;

var responseClient = client.GetResponsesClient("DeepSeek-V3.1");
var result = await responseClient.CreateResponseAsync(new CreateResponseOptions(
    [ResponseItem.CreateUserMessageItem("How many languages are in the world?")])
    { MaxOutputTokenCount = 2000 }
);

Console.WriteLine(result.Value.GetOutputText());

Argumentation

Hinweis

Diese Informationen zu Inhalten zur Schlussfolgerung gelten nicht für Azure OpenAI-Modelle. Azure OpenAI-Begründungsmodelle verwenden die Funktion reasoning summaries.

OpenAI SDK
Azure AI Inference SDK

using System.Text;
using OpenAI.Responses;

var responseClient = client.GetResponsesClient("DeepSeek-R1-0528");
var result = await responseClient.CreateResponseAsync(new CreateResponseOptions(
    [ResponseItem.CreateUserMessageItem("How many languages are in the world?")])
    { MaxOutputTokenCount = 2000 }
);

// Walk OutputItems for ReasoningResponseItem entries and join SummaryParts text.
var sb = new StringBuilder();
foreach (var item in result.Value.OutputItems)
{
    if (item is not ReasoningResponseItem reasoning) continue;
    foreach (var part in reasoning.SummaryParts)
    {
        if (part is ReasoningSummaryTextPart textPart && !string.IsNullOrEmpty(textPart.Text))
        {
            if (sb.Length > 0) sb.Append('\n');
            sb.Append(textPart.Text);
        }
    }
}

Console.WriteLine($"Thinking: {sb.ToString().Trim()}");
Console.WriteLine($"Answer:   {result.Value.GetOutputText()}");

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...
Answer:   There are approximately 7,000 languages spoken around the world today.

Hinweis

using Azure.AI.Inference;
using System.Text.RegularExpressions;

ChatCompletionsOptions requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
    Model = "DeepSeek-R1-0528", // Optional for single-model endpoints
};

Response<ChatCompletions> response = client.Complete(requestOptions);
string content = response.Value.Choices[0].Message.Content;

Regex regex = new Regex(@"<think>(.*?)</think>(.*)", RegexOptions.Singleline);
Match match = regex.Match(content);

if (match.Success)
{
    Console.WriteLine($"Thinking: {match.Groups[1].Value.Trim()}");
    Console.WriteLine($"Answer:   {match.Groups[2].Value.Trim()}");
}
else
{
    Console.WriteLine($"Response: {content}");
}

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...
Answer:   There are approximately 7,000 languages spoken around the world today.

Wenn Sie mehrteilige Unterhaltung führen, vermeiden Sie es, Begründungsinhalte im Chatverlauf zu senden, da diese tendenziell lange Erklärungen erzeugen.

Einbettungen

OpenAI SDK
Azure AI Inference SDK

using OpenAI;
using OpenAI.Embeddings;
using System.ClientModel;

EmbeddingClient client = new(
    "text-embedding-3-small",
    credential: new ApiKeyCredential("API-KEY"),
    options: new OpenAIClientOptions()
    {

        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
    }
);

string input = "This is a test";

OpenAIEmbedding embedding = client.GenerateEmbedding(input);
ReadOnlyMemory<float> vector = embedding.ToFloats();
Console.WriteLine($"Embeddings: [{string.Join(", ", vector.ToArray())}]");

using Azure;
using Azure.AI.Inference;

EmbeddingsClient client = new EmbeddingsClient(
    new Uri("https://<resource>.services.ai.azure.com/models"),
    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);

EmbeddingsOptions embeddingsOptions = new EmbeddingsOptions()
{
    Input = { "Your text string goes here" },
    Model = "text-embedding-3-small"
};

Response<EmbeddingsResult> response = client.Embed(embeddingsOptions);
ReadOnlyMemory<float> embedding = response.Value.Data[0].Embedding;

Konfiguration

Installieren Sie das OpenAI SDK:

npm install openai

Installieren Sie für Microsoft Entra ID Authentifizierung auch Folgendes:

npm install @azure/identity

Clientkonfiguration

Mit API-Schlüsselauthentifizierung:

OpenAI SDK
Azure AI Inference SDK

import { OpenAI } from "openai";

const client = new OpenAI({
    baseURL: "https://<resource>.openai.azure.com/openai/v1/",
    apiKey: process.env.AZURE_OPENAI_API_KEY
});

import ModelClient from "@azure-rest/ai-inference";
import { AzureKeyCredential } from "@azure/core-auth";

const client = ModelClient(
    "https://<resource>.services.ai.azure.com/models", 
    new AzureKeyCredential(process.env.AZURE_INFERENCE_CREDENTIAL)
);

Mit Microsoft Entra ID Authentifizierung:

OpenAI SDK
Azure AI Inference SDK

import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import { OpenAI } from "openai";

const tokenProvider = getBearerTokenProvider(
    new DefaultAzureCredential(),
    'https://ai.azure.com/.default'
);

const client = new OpenAI({
    baseURL: "https://<resource>.openai.azure.com/openai/v1/",
    apiKey: tokenProvider
});

import ModelClient from "@azure-rest/ai-inference";
import { DefaultAzureCredential } from "@azure/identity";

const clientOptions = { 
    credentials: { 
        scopes: ["https://cognitiveservices.azure.com/.default"] 
    } 
};

const client = ModelClient(
    "https://<resource>.services.ai.azure.com/models", 
    new DefaultAzureCredential(),
    clientOptions
);

Chatvervollständigung

OpenAI SDK
Azure AI Inference SDK

const completion = await client.chat.completions.create({
    model: "DeepSeek-V3.1", // Required: your deployment name
    messages: [
        { role: "system", content: "You are a helpful assistant." },
        { role: "user", content: "How many languages are in the world?" }
    ]
});

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

const response = await client.path("/chat/completions").post({
    body: {
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "How many languages are in the world?" }
        ],
        model: "DeepSeek-V3.1" // Optional for single-model endpoints
    }
});

console.log(response.body.choices[0].message.content);

Streaming

OpenAI SDK
Azure AI Inference SDK

const stream = await client.chat.completions.create({
    model: "DeepSeek-V3.1",
    messages: [
        { role: "system", content: "You are a helpful assistant." },
        { role: "user", content: "Write a poem about Azure." }
    ],
    stream: true
});

for await (const chunk of stream) {
    if (chunk.choices[0]?.delta?.content) {
        process.stdout.write(chunk.choices[0].delta.content);
    }
}

const response = await client.path("/chat/completions").post({
    body: {
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "Write a poem about Azure." }
        ],
        model: "DeepSeek-V3.1",
        stream: true
    }
}).asNodeStream();

for await (const chunk of response) {
    if (chunk.choices && chunk.choices[0]?.delta?.content) {
        process.stdout.write(chunk.choices[0].delta.content);
    }
}

Responses

Die Antwort-API ist die zustandsbehaftete Schnittstelle von OpenAI, die ein strukturiertes output Array zurückgibt, das Nachrichten-, Toolaufrufe und Begründungselemente enthält.

OpenAI SDK
Azure AI Inference SDK

const response = await client.responses.create({
    model: "DeepSeek-V3.1", // Required: your deployment name
    input: "How many languages are in the world?",
    max_output_tokens: 2000,
});

console.log(response.output_text);

Argumentation

Hinweis

Diese Informationen zu Inhalten zur Schlussfolgerung gelten nicht für Azure OpenAI-Modelle. Azure OpenAI-Begründungsmodelle verwenden die Funktion reasoning summaries.

OpenAI SDK
Azure AI Inference SDK

const response = await client.responses.create({
    model: "DeepSeek-R1-0528", // Required: your deployment name
    input: "How many languages are in the world?",
    max_output_tokens: 2000,
});

// Walk response.output for items of type "reasoning" and join summary[].text.
const parts = [];
for (const item of response?.output ?? []) {
    if (item?.type !== "reasoning") continue;
    for (const s of item?.summary ?? []) {
        if (s?.text) parts.push(s.text);
    }
}
const reasoningSummary = parts.join("\n").trim();

console.log("Thinking:", reasoningSummary);
console.log("Answer:  ", response.output_text);

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...
Answer:   There are approximately 7,000 languages spoken around the world today.

Hinweis

const response = await client.path("/chat/completions").post({
    body: {
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "How many languages are in the world?" }
        ],
        model: "DeepSeek-R1-0528" // Optional for single-model endpoints
    }
});

const content = response.body.choices[0].message.content;
const match = content.match(/<think>(.*?)<\/think>(.*)/s);

if (match) {
    console.log("Thinking:", match[1].trim());
    console.log("Answer:  ", match[2].trim());
} else {
    console.log("Response:", content);
}

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...
Answer:   There are approximately 7,000 languages spoken around the world today.

Wenn Sie mehrteilige Unterhaltung führen, vermeiden Sie es, Begründungsinhalte im Chatverlauf zu senden, da diese tendenziell lange Erklärungen erzeugen.

Einbettungen

OpenAI SDK
Azure AI Inference SDK

import OpenAI from "openai";
import { getBearerTokenProvider, DefaultAzureCredential } from "@azure/identity";

const tokenProvider = getBearerTokenProvider(
    new DefaultAzureCredential(),
    'https://ai.azure.com/.default');
const client = new OpenAI({
    baseURL: "https://<resource>.openai.azure.com/openai/v1/",
    apiKey: tokenProvider
});

const embedding = await client.embeddings.create({
  model: "text-embedding-3-large", // Required: your deployment name
  input: "The quick brown fox jumped over the lazy dog",
  encoding_format: "float",
});

console.log(embedding);

import ModelClient from "@azure-rest/ai-inference";
import { AzureKeyCredential } from "@azure/core-auth";

const client = ModelClient(
    "https://<resource>.services.ai.azure.com/models",
    new AzureKeyCredential(process.env.AZURE_INFERENCE_CREDENTIAL)
);

const response = await client.path("/embeddings").post({
    body: {
        input: ["Your text string goes here"],
        model: "text-embedding-3-small"
    }
});

const embedding = response.body.data[0].embedding;

Konfiguration

Fügen Sie das OpenAI SDK zu Ihrem Projekt hinzu. Überprüfen Sie das OpenAI Java GitHub Repository auf die neuesten Versions- und Installationsanweisungen.

Fügen Sie für Microsoft Entra ID Authentifizierung auch Folgendes hinzu:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.18.0</version>
</dependency>

Clientkonfiguration

Mit API-Schlüsselauthentifizierung:

OpenAI SDK
Azure AI Inference SDK

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .baseUrl("https://<resource>.openai.azure.com/openai/v1/")
    .apiKey(System.getenv("AZURE_OPENAI_API_KEY"))
    .build();

import com.azure.ai.inference.ChatCompletionsClient;
import com.azure.ai.inference.ChatCompletionsClientBuilder;
import com.azure.core.credential.AzureKeyCredential;

ChatCompletionsClient client = new ChatCompletionsClientBuilder()
    .credential(new AzureKeyCredential(System.getenv("AZURE_INFERENCE_CREDENTIAL")))
    .endpoint("https://<resource>.services.ai.azure.com/models")
    .buildClient();

Mit Microsoft Entra ID Authentifizierung:

OpenAI SDK
Azure AI Inference SDK

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;

DefaultAzureCredential tokenCredential = new DefaultAzureCredentialBuilder().build();

OpenAIClient client = OpenAIOkHttpClient.builder()
    .baseUrl("https://<resource>.openai.azure.com/openai/v1/")
    .credential(BearerTokenCredential.create(
        AuthenticationUtil.getBearerTokenSupplier(
            tokenCredential, 
            "https://ai.azure.com/.default"
        )
    ))
    .build();

import com.azure.ai.inference.ChatCompletionsClient;
import com.azure.ai.inference.ChatCompletionsClientBuilder;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.core.credential.TokenCredential;

TokenCredential credential = new DefaultAzureCredentialBuilder().build();
ChatCompletionsClient client = new ChatCompletionsClientBuilder()
    .credential(credential)
    .endpoint("https://<resource>.services.ai.azure.com/models")
    .buildClient();

Chatvervollständigung

OpenAI SDK
Azure AI Inference SDK

import com.openai.models.chat.completions.*;

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .addSystemMessage("You are a helpful assistant.")
    .addUserMessage("How many languages are in the world?")
    .model("DeepSeek-V3.1") // Required: your deployment name
    .build();

ChatCompletion completion = client.chat().completions().create(params);
System.out.println(completion.choices().get(0).message().content());

import com.azure.ai.inference.models.*;
import java.util.List;

List<ChatRequestMessage> messages = List.of(
    new ChatRequestSystemMessage("You are a helpful assistant."),
    new ChatRequestUserMessage("How many languages are in the world?")
);

ChatCompletionsOptions options = new ChatCompletionsOptions(messages);
options.setModel("DeepSeek-V3.1"); // Optional for single-model endpoints

ChatCompletions response = client.complete(options);
System.out.println(response.getChoices().get(0).getMessage().getContent());

Streaming

OpenAI SDK
Azure AI Inference SDK

import com.openai.models.chat.completions.*;
import java.util.stream.Stream;

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .addSystemMessage("You are a helpful assistant.")
    .addUserMessage("Write a poem about Azure.")
    .model("DeepSeek-V3.1") // Required: your deployment name
    .build();

Stream<ChatCompletionChunk> stream = client.chat().completions().createStreaming(params);

stream.forEach(chunk -> {
    if (chunk.choices() != null && !chunk.choices().isEmpty()) {
        String content = chunk.choices().get(0).delta().content();
        if (content != null) {
            System.out.print(content);
        }
    }
});

import com.azure.ai.inference.models.*;

List<ChatRequestMessage> messages = List.of(
    new ChatRequestSystemMessage("You are a helpful assistant."),
    new ChatRequestUserMessage("Write a poem about Azure.")
);

ChatCompletionsOptions options = new ChatCompletionsOptions(messages);
options.setModel("DeepSeek-V3.1");

IterableStream<ChatCompletions> response = client.completeStream(options);

response.forEach(update -> {
    if (update.getChoices() != null && !update.getChoices().isEmpty()) {
        String content = update.getChoices().get(0).getDelta().getContent();
        if (content != null) {
            System.out.print(content);
        }
    }
});

Responses

Die Antwort-API ist die zustandsbehaftete Schnittstelle von OpenAI, die ein strukturiertes output Array zurückgibt, das Nachrichten-, Toolaufrufe und Begründungselemente enthält.

OpenAI SDK
Azure AI Inference SDK

import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

Response response = client.responses().create(
    ResponseCreateParams.builder()
        .model("DeepSeek-V3.1") // Required: your deployment name
        .input("How many languages are in the world?")
        .maxOutputTokens(2000)
        .build()
);

System.out.println(response.outputText());

Argumentation

Hinweis

Diese Informationen zu Inhalten zur Schlussfolgerung gelten nicht für Azure OpenAI-Modelle. Azure OpenAI-Begründungsmodelle verwenden die Funktion reasoning summaries.

OpenAI SDK
Azure AI Inference SDK

import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

Response response = client.responses().create(
    ResponseCreateParams.builder()
        .model("DeepSeek-R1-0528") // Required: your deployment name
        .input("How many languages are in the world?")
        .maxOutputTokens(2000)
        .build()
);

// Walk response.output() for items of type "reasoning" and join summary[].text.
StringBuilder sb = new StringBuilder();
response.output().stream()
    .flatMap(item -> item.reasoning().stream())
    .flatMap(reasoning -> reasoning.summary().stream())
    .forEach(summary -> {
        String text = summary.text();
        if (text != null && !text.isEmpty()) {
            if (sb.length() > 0) sb.append("\n");
            sb.append(text);
        }
    });

System.out.println("Thinking: " + sb.toString().trim());

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...

Hinweis

import com.azure.ai.inference.models.*;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

List<ChatRequestMessage> messages = List.of(
    new ChatRequestSystemMessage("You are a helpful assistant."),
    new ChatRequestUserMessage("How many languages are in the world?")
);

ChatCompletionsOptions options = new ChatCompletionsOptions(messages);
options.setModel("DeepSeek-R1-0528"); // Optional for single-model endpoints

ChatCompletions response = client.complete(options);
String content = response.getChoices().get(0).getMessage().getContent();

Pattern pattern = Pattern.compile("<think>(.*?)</think>(.*)", Pattern.DOTALL);
Matcher matcher = pattern.matcher(content);

if (matcher.find()) {
    System.out.println("Thinking: " + matcher.group(1).trim());
    System.out.println("Answer:   " + matcher.group(2).trim());
} else {
    System.out.println("Response: " + content);
}

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...
Answer:   There are approximately 7,000 languages spoken around the world today.

Wenn Sie mehrteilige Unterhaltung führen, vermeiden Sie es, Begründungsinhalte im Chatverlauf zu senden, da diese tendenziell lange Erklärungen erzeugen.

Einbettungen

OpenAI SDK
Azure AI Inference SDK

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.embeddings.EmbeddingCreateParams;
import com.openai.models.embeddings.EmbeddingModel;

public final class EmbeddingsExample {
    private EmbeddingsExample() {}

    public static void main(String[] args) {
        // Configures using one of:
        // - The `OPENAI_API_KEY` environment variable
        // - The `OPENAI_BASE_URL` and `AZURE_OPENAI_KEY` environment variables
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        EmbeddingCreateParams createParams = EmbeddingCreateParams.builder()
                .input("The quick brown fox jumped over the lazy dog")
                .model(EmbeddingModel.TEXT_EMBEDDING_3_SMALL)
                .build();

        System.out.println(client.embeddings().create(createParams));
    }
}

import com.azure.ai.inference.EmbeddingsClient;
import com.azure.ai.inference.EmbeddingsClientBuilder;
import com.azure.core.credential.AzureKeyCredential;

EmbeddingsClient client = new EmbeddingsClientBuilder()
    .credential(new AzureKeyCredential(System.getenv("AZURE_INFERENCE_CREDENTIAL")))
    .endpoint("https://<resource>.services.ai.azure.com/models")
    .buildClient();

EmbeddingsOptions embeddingsOptions = new EmbeddingsOptions(
    List.of("Your text string goes here")
);
embeddingsOptions.setModel("text-embedding-3-small");

EmbeddingsResult response = client.embed(embeddingsOptions);
List<Float> embedding = response.getData().get(0).getEmbedding();

Konfiguration

Installieren Sie das OpenAI SDK:

go get github.com/openai/openai-go/v3

Installieren Sie für Microsoft Entra ID Authentifizierung auch Folgendes:

go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity

Clientkonfiguration

Mit API-Schlüsselauthentifizierung:

OpenAI SDK
Azure AI Inference SDK

import (
    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/option"
)

client := openai.NewClient(
    option.WithBaseURL("https://<resource>.openai.azure.com/openai/v1/"),
    option.WithAPIKey(os.Getenv("AZURE_OPENAI_API_KEY")),
)

Mit Microsoft Entra ID Authentifizierung:

OpenAI SDK
Azure AI Inference SDK

import (
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/azure"
    "github.com/openai/openai-go/v3/option"
)

tokenCredential, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
    panic(err)
}

client := openai.NewClient(
    option.WithBaseURL("https://<resource>.openai.azure.com/openai/v1/"),
    azure.WithTokenCredential(tokenCredential),
)

Chatvervollständigung

OpenAI SDK
Azure AI Inference SDK

import (
    "context"
    "fmt"
    "github.com/openai/openai-go/v3"
)

chatCompletion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
    Messages: []openai.ChatCompletionMessageParamUnion{
        openai.SystemMessage("You are a helpful assistant."),
        openai.UserMessage("What is Azure AI?"),
    },
    Model: "DeepSeek-V3.1", // Required: your deployment name
})

if err != nil {
    panic(err.Error())
}

fmt.Println(chatCompletion.Choices[0].Message.Content)

Streaming

OpenAI SDK
Azure AI Inference SDK

import (
    "context"
    "fmt"
    "github.com/openai/openai-go/v3"
)

stream := client.Chat.Completions.NewStreaming(context.TODO(), openai.ChatCompletionNewParams{
    Messages: []openai.ChatCompletionMessageParamUnion{
        openai.SystemMessage("You are a helpful assistant."),
        openai.UserMessage("Write a poem about Azure."),
    },
    Model: "DeepSeek-V3.1", // Required: your deployment name
})

for stream.Next() {
    chunk := stream.Current()
    if len(chunk.Choices) > 0 && chunk.Choices[0].Delta.Content != "" {
        fmt.Print(chunk.Choices[0].Delta.Content)
    }
}

if err := stream.Err(); err != nil {
    panic(err.Error())
}

Responses

Die Antwort-API ist die zustandsbehaftete Schnittstelle von OpenAI, die ein strukturiertes output Array zurückgibt, das Nachrichten-, Toolaufrufe und Begründungselemente enthält.

OpenAI SDK
Azure AI Inference SDK

import (
    "context"
    "fmt"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

resp, err := client.Responses.New(context.TODO(), responses.ResponseNewParams{
    Model: "DeepSeek-V3.1", // Required: your deployment name
    Input: responses.ResponseNewParamsInputUnion{
        OfString: openai.String("How many languages are in the world?"),
    },
    MaxOutputTokens: openai.Int(2000),
})
if err != nil {
    panic(err.Error())
}

fmt.Println(resp.OutputText())

Argumentation

Hinweis

Diese Informationen zu Inhalten zur Schlussfolgerung gelten nicht für Azure OpenAI-Modelle. Azure OpenAI-Begründungsmodelle verwenden die Funktion reasoning summaries.

OpenAI SDK
Azure AI Inference SDK

import (
    "context"
    "fmt"
    "strings"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

resp, err := client.Responses.New(context.TODO(), responses.ResponseNewParams{
    Model: "DeepSeek-R1-0528", // Required: your deployment name
    Input: responses.ResponseNewParamsInputUnion{
        OfString: openai.String("How many languages are in the world?"),
    },
    MaxOutputTokens: openai.Int(2000),
})
if err != nil {
    panic(err.Error())
}

// Walk resp.Output for items of type "reasoning" and join summary[].text.
var parts []string
for _, item := range resp.Output {
    if item.Type != "reasoning" {
        continue
    }
    for _, s := range item.Summary {
        if s.Text != "" {
            parts = append(parts, s.Text)
        }
    }
}
reasoningSummary := strings.TrimSpace(strings.Join(parts, "\n"))

fmt.Println("Thinking:", reasoningSummary)
fmt.Println("Answer:  ", resp.OutputText())

Die Ausgabe lautet wie folgt:

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer...
Answer:   There are approximately 7,000 languages spoken around the world today.

Hinweis

Wenn Sie mehrteilige Unterhaltung führen, vermeiden Sie es, Begründungsinhalte im Chatverlauf zu senden, da diese tendenziell lange Erklärungen erzeugen.

Einbettungen

OpenAI SDK
Azure AI Inference SDK

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/azure"
    "github.com/openai/openai-go/v3/option"
)

func main() {
    tokenCredential, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatalf("Error creating credential:%s", err)
    }
    // Create a client with Azure OpenAI endpoint and Entra ID credentials
    client := openai.NewClient(
        option.WithBaseURL("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"),
        azure.WithTokenCredential(tokenCredential),
    )

    inputText := "The quick brown fox jumped over the lazy dog"

    // Make the embedding request synchronously
    resp, err := client.Embeddings.New(context.Background(), openai.EmbeddingNewParams{
        Model: openai.EmbeddingModel("text-embedding-3-large"), // Use your deployed model name on Azure
        Input: openai.EmbeddingNewParamsInputUnion{
            OfArrayOfStrings: []string{inputText},
        },
    })
    if err != nil {
        log.Fatalf("Failed to get embedding: %s", err)
    }

    if len(resp.Data) == 0 {
        log.Fatalf("No embedding data returned.")
    }

    // Print embedding information
    embedding := resp.Data[0].Embedding
    fmt.Printf("Embedding Length: %d\n", len(embedding))
    fmt.Println("Embedding Values:")
    for _, value := range embedding {
        fmt.Printf("%f, ", value)
    }
    fmt.Println()
}

Allgemeine Migrationsmuster

Modellparameterbehandlung

Azure AI Inference SDK: Der Parameter model ist für Endpunkte mit einem Modell optional, aber für Multimodellendpunkte erforderlich.
OpenAI SDK: Der model Parameter ist immer erforderlich und sollte auf Ihren Bereitstellungsnamen festgelegt werden.

Endpunkt-URL-Format

Azure AI Inference SDK: Verwendet https://<resource>.services.ai.azure.com/models.
OpenAI SDK: Verwendet https://<resource>.openai.azure.com/openai/v1 (stellt eine Verbindung mit der OpenAI v1-API bereit).

Antwortstruktur

Die Antwortstruktur ist ähnlich, weist jedoch einige Unterschiede auf:

Azure AI Inference SDK: Gibt ChatCompletions-Objekt mit choices[].message.content zurück.
OpenAI SDK: Gibt ChatCompletion objekt mit choices[].message.content.

Beide SDKs bieten ähnliche Zugriffsmuster für Antwortdaten, darunter:

Nachrichteninhalt
Tokenverwendung
Modellinformationen
Abschlussgrund

Migrationscheckliste

Verwenden Sie diese Checkliste, um eine reibungslose Migration sicherzustellen:

Installieren des OpenAI SDK für Ihre Programmiersprache
Aktualisieren des Authentifizierungscodes (API-Schlüssel oder Microsoft Entra ID)
Ändern von Endpunkt-URLs von .services.ai.azure.com/models zu .openai.azure.com/openai/v1/
Ändern Sie den Anmeldeinformationsbereich von https://cognitiveservices.azure.com/.default auf https://ai.azure.com/.default
Aktualisieren des Clientinitialisierungscodes
Geben Sie immer den model Parameter mit dem Bereitstellungsnamen an.
Aktualisierungsanforderungsmethodeaufrufe (complete → chat.completions.create)
Aktualisieren von Streamingcode bei Bedarf
Aktualisieren der Fehlerbehandlung zur Verwendung von OpenAI SDK-Ausnahmen
Gründliches Testen aller Funktionen
Aktualisieren von Dokumentationen und Codekommentaren

Problembehandlung

Authentifizierungsfehler

Wenn Authentifizierungsfehler auftreten:

Überprüfen Sie, ob Der API-Schlüssel korrekt ist und nicht abgelaufen ist.
Stellen Sie für Microsoft Entra ID sicher, dass Ihre Anwendung über die richtigen Berechtigungen verfügt.
Prüfen Sie, ob der Bereich der Anmeldeinformationen auf https://ai.azure.com/.default festgelegt ist.

Endpunktfehler

Wenn Endpunktfehler angezeigt werden:

Überprüfen Sie, ob das Endpunkt-URL-Format /openai/v1/ am Ende enthält.
Stellen Sie sicher, dass der Ressourcenname korrekt ist.
Überprüfen Sie, ob die Modellbereitstellung vorhanden ist und aktiv ist.

Fehler „Modell nicht gefunden“

Wenn die Fehlermeldung "Modell nicht gefunden" angezeigt wird:

Überprüfen Sie, ob Sie Ihren Bereitstellungsnamen verwenden, nicht den Modellnamen.
Überprüfen Sie, ob die Bereitstellung in Ihrer Microsoft Foundry-Ressource aktiv ist.
Stellen Sie sicher, dass der Bereitstellungsname exakt übereinstimmt (Groß-/Kleinschreibung wird beachtet).

Feedback

War diese Seite hilfreich?

Last updated on 2026-06-16

Migrieren von Azure AI Inference SDK zu OpenAI SDK

Vorteile der Migration

Wichtige Unterschiede

Konfiguration

Clientkonfiguration

Chatvervollständigung

Streaming

Responses

Argumentation

Einbettungen

Konfiguration

Clientkonfiguration

Chatvervollständigung

Streaming

Responses

Argumentation

Einbettungen

Konfiguration

Clientkonfiguration

Chatvervollständigung

Streaming

Responses

Argumentation

Einbettungen

Konfiguration

Clientkonfiguration

Chatvervollständigung

Streaming

Responses

Argumentation

Einbettungen

Konfiguration

Clientkonfiguration

Chatvervollständigung

Streaming

Responses

Argumentation

Einbettungen

Allgemeine Migrationsmuster

Modellparameterbehandlung

Endpunkt-URL-Format

Antwortstruktur

Migrationscheckliste

Problembehandlung

Authentifizierungsfehler

Endpunktfehler

Fehler „Modell nicht gefunden“

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen