Verwenden Sie Reasoning-Modelle mit Microsoft Foundry Models

Reasoning-Modelle nutzen zusätzliche Rechenleistung, um komplexe Probleme zu lösen, bevor sie eine Antwort zurückgeben. In diesem Artikel wird gezeigt, DeepSeek-V4-Prowie Sie mithilfe der OpenAI-Chatabschluss-API aus einem Foundry-Projekt ein Nicht-OpenAI-Begründungsmodell aufrufen.

Voraussetzungen

Ein Azure-Abonnement.
Ein Foundry-Projekt. Diese Art von Projekt wird unter einer Foundry-Ressource verwaltet. Wenn Sie kein Foundry-Projekt haben, siehe Ein Projekt für Microsoft Foundry erstellen.
Die Endpunkt-URL Ihres Foundry-Projekts, die die Form https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME hat.
Ein bereitgestelltes Reasoning-Model. In diesem Artikel wird DeepSeek-V4-Pro verwendet. Ersetzen Sie den Modellnamen bei Bedarf durch Ihren Bereitstellungsnamen.
Die SDK- oder Befehlszeilentools für die von Ihnen ausgewählte Sprache. Verwenden Sie für C# das .NET 10 SDK. Die C#-Beispiele werden mit den OpenAI Paketen 2.13.0 und Azure.Identity 1.21.0 getestet.
Berechtigung zum Zugriff auf das Projekt und die Modellbereitstellung. Melden Sie sich bei der schlüssellosen Authentifizierung mit einer Identität an, die über den erforderlichen Zugriff auf das Foundry-Projekt verfügt.

Verwenden des KI-Modellstartkits

Die Beispiele im KI-Modell-Starterkit verwenden standardmäßige OpenAI-Clients mit einem Foundry-Projektendpunkt und dem /openai/v1 Pfad. Das Starter Kit enthält ein vollständiges Beispiel für ein DeepSeek-Begründungsmodell. Die aktuellen Codebeispiele verwenden die Responses API. In den Beispielen in diesem Artikel werden Chatabschlusse für Bereitstellungen verwendet, die diese API verfügbar machen.

Einrichten des Clients

Verwenden Sie Microsoft Entra ID, um den OpenAI-Client zu authentifizieren. Der Tokenbereich für den Foundry-Projektendpunkt lautet https://ai.azure.com/.default. Der Endpunkt muss der Projektendpunkt sein, nicht der Ressourcenendpunkt, und an die Basis-URL des Clients muss /openai/v1 angehängt werden.

Installieren openai und azure-identity Bibliotheken.
```
pip install --upgrade openai azure-identity
```

Verwenden Sie den folgenden Code, um das OpenAI-Clientobjekt in der Projektroute zu konfigurieren.

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

project_endpoint = "https://<resource>.services.ai.azure.com/api/projects/<project>"
token_provider = get_bearer_token_provider(
              DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
              base_url=project_endpoint.rstrip("/") + "/openai/v1",
              api_key=token_provider,
)

Installieren openai und @azure/identity.
```
npm install openai @azure/identity
```

Verwenden Sie den folgenden Code, um das OpenAI-Clientobjekt in der Projektroute zu konfigurieren:

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

const projectEndpoint = "https://<resource>.services.ai.azure.com/api/projects/<project>";
const tokenProvider = getBearerTokenProvider(
       new DefaultAzureCredential(), "https://ai.azure.com/.default"
);
const client = new OpenAI({
       baseURL: `${projectEndpoint.replace(/\/+$/, "")}/openai/v1`,
       apiKey: tokenProvider,
});

Fügen Sie openai-java und azure-identity Ihrem Projekt hinzu, und konfigurieren Sie dann das OpenAI-Clientobjekt in der Projektroute. Das folgende Clientmuster verwendet das OpenAI Java SDK und den Entra-Tokenanbieter:

import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.azure.identity.AuthenticationUtil;

String projectEndpoint = "https://<resource>.services.ai.azure.com/api/projects/<project>";
OpenAIClient client = OpenAIOkHttpClient.builder()
              .baseUrl(projectEndpoint.replaceAll("/+$", "") + "/openai/v1")
              .credential(BearerTokenCredential.create(AuthenticationUtil.getBearerTokenSupplier(
                            new DefaultAzureCredentialBuilder().build(), "https://ai.azure.com/.default")))
              .build();

Installieren Sie die OpenAI und Azure.Identity Pakete.

dotnet add package OpenAI --version 2.13.0
dotnet add package Azure.Identity --version 1.21.0

Verwenden Sie den folgenden Code, um das OpenAI-Clientobjekt in der Projektroute zu konfigurieren.

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: "DeepSeek-V4-Pro", // Replace with your deployment name, not the model ID 
              authenticationPolicy: tokenPolicy,
              options: new OpenAIClientOptions { Endpoint = new Uri(
                            "https://<resource>.services.ai.azure.com/api/projects/<project>/openai/v1") });

Rufen Sie ein Entra-Token für den https://ai.azure.com/.default-Bereich ab, und senden Sie es als Bearertoken. Für /openai/v1 ist kein Abfrageparameter api-version erforderlich.

export AZURE_AI_AUTH_TOKEN="<entra-token>"

Erstellen eines einfachen Chatabschlusses

Senden Sie eine Benutzernachricht an das bereitgestellte Begründungsmodell. Die Antwort enthält die endgültige Antwort in message.content. Je nach Modell kann die Antwort auch Inhalte zur Begründung in message.reasoning_content enthalten.

response = client.chat.completions.create(
              model="DeepSeek-V4-Pro", # Replace with your deployment name, not the model ID
              messages=[{"role": "user", "content": "How many languages are spoken worldwide?"}],
)
print(response.choices[0].message.content)
print(getattr(response.choices[0].message, "reasoning_content", None))

const response = await client.chat.completions.create({
       model: "DeepSeek-V4-Pro", // Replace with your deployment name, not the model ID
       messages: [{ role: "user", content: "How many languages are spoken worldwide?" }],
});
console.log(response.choices[0]?.message.content);
console.log(response.choices[0]?.message.reasoning_content);

import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
              .model("DeepSeek-V4-Pro") // Replace with your deployment name, not the model ID
              .addUserMessage("How many languages are spoken worldwide?")
              .build();
ChatCompletion response = client.chat().completions().create(params);
System.out.println(response.choices().get(0).message().content().orElse(""));

ChatCompletion response = await client.CompleteChatAsync([
              new UserChatMessage("How many languages are spoken worldwide?")
]);
Console.WriteLine(response.Content[0].Text);

curl -X POST "https://<resource>.services.ai.azure.com/api/projects/<project>/openai/v1/chat/completions" \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \
       -d '{
              "model": "DeepSeek-V4-Pro",
              "messages": [{"role": "user", "content": "How many languages are spoken worldwide?"}]
       }'

Lesen von Begründungsinhalten

Einige Nicht-OpenAI-Begründungsmodelle geben ein reasoning_content Feld zusammen mit dem endgültigen contentzurück. Reasoning-Inhalte können umfangreich sein und werden auf die Tokennutzung angerechnet. Fügen Sie es nicht dem Nachrichtenverlauf einer Multi-Turn-Unterhaltung hinzu, es sei denn, die Dokumentation des Modells erfordert dies ausdrücklich. Speichern oder anzeigen Sie sie nur, wenn Ihre Anwendung sie benötigt, und behandeln Sie sie als Modellausgabe anstelle einer überprüften Erklärung.

Verwenden Sie für Modelle, die reasoning_content nicht zurückgeben, den endgültigen content-Wert. Das Feld ist modellabhängig und nicht für jedes Reasoning-Modell verfügbar.

Vervollständigung streamen

Setzen Sie stream auf true, um Server-Sent Events zu empfangen, während das Modell eine Ausgabe generiert. Inhalte zum logischen Schlussfolgern und Inhalte der endgültigen Antwort können in verschiedenen Delta-Feldern ankommen. In den folgenden Beispielen werden endgültige Antwortinhalte gedruckt, sobald sie eintreffen.

stream = client.chat.completions.create(
              model="DeepSeek-V4-Pro",
              messages=[{"role": "user", "content": "Explain photosynthesis briefly."}],
              stream=True,
)
for event in stream:
              if event.choices:
                            content = event.choices[0].delta.content
                            if content:
                                          print(content, end="", flush=True)

const stream = await client.chat.completions.create({
       model: "DeepSeek-V4-Pro",
       messages: [{ role: "user", content: "Explain photosynthesis briefly." }],
       stream: true,
});
for await (const event of stream) {
       const content = event.choices[0]?.delta?.content;
       if (content) process.stdout.write(content);
}

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
              .model("DeepSeek-V4-Pro")
              .addUserMessage("Explain photosynthesis briefly.")
              .build();
client.chat().completions().createStreaming(params).stream()
              .flatMap(chunk -> chunk.choices().stream())
              .flatMap(choice -> choice.delta().content().stream())
              .forEach(System.out::print);

var stream = client.CompleteChatStreamingAsync([
              new UserChatMessage("Explain photosynthesis briefly.")
]);
await foreach (StreamingChatCompletionUpdate update in stream)
{
              foreach (ChatMessageContentPart part in update.ContentUpdate)
              {
                            Console.Write(part.Text);
              }
}

curl -N -X POST "https://<resource>.services.ai.azure.com/api/projects/<project>/openai/v1/chat/completions" \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \
       -d '{"model":"DeepSeek-V4-Pro","messages":[{"role":"user","content":"Explain photosynthesis briefly."}],"stream":true}'

Auswählen von Parametern für Reasoning-Modelle

Reasoning-Modelle unterstützen häufig keine Parameter, die bei anderen Chat-Completion-Modellen üblich sind, einschließlich temperature, top_p, presence_penalty und frequency_penalty. Überprüfen Sie die Modelldetails im Foundry-Modellkatalog, bevor Sie optionale Parameter hinzufügen. Legen Sie einen ausreichenden max_completion_tokens Wert fest, da die Begründungstoken und die endgültigen Antworttoken beide auf den Grenzwert zählen.

Verwenden Sie kurze, direkte Eingabeaufforderungen. Vermeiden Sie es, das Modell aufzufordern, eine Gedankenkette aufzudecken. Fügen Sie bei Gesprächen über mehrere Runden die endgültige Antwort anstelle des Begründungsinhalts an, wenn das Modell beides zurückgibt.

Antworten zur Inhaltssicherheit verarbeiten

Foundry wendet die Inhaltsfilterung auf unterstützte Bereitstellungen an. Eine Anforderung oder Antwort kann blockiert werden, wenn sie gegen eine konfigurierte Inhaltssicherheitsrichtlinie verstößt. Behandeln Sie die Beendigungsgrund content_filter und die HTTP 400-Fehler in Ihrer Anwendung, zeigen Sie dem Benutzer eine hilfreiche Meldung an, und wiederholen Sie denselben gesperrten Prompt nicht unverändert.

{
       "error": {
              "code": "content_filter",
              "message": "The response was filtered due to the prompt triggering a content policy."
       }
}

Informationen zu Konfigurations- und Steuerungsoptionen finden Sie unter Azure KI Inhaltssicherheit.

Über Schlussfolgerungsmodelle

Reasoning-Modelle erreichen ein höheres Leistungsniveau in Bereichen wie Mathematik, Codierung, Wissenschaft, Strategie und Logistik. Diese Modelle verwenden explizit eine Gedankenkette, um alle möglichen Pfade zu untersuchen, bevor eine Antwort generiert wird. Sie überprüfen ihre Antworten, während sie sie produzieren, was ihnen hilft, genauere Schlussfolgerungen zu treffen. Infolgedessen benötigen Reasoning-Modelle möglicherweise weniger Kontext-Prompts, um effektive Ergebnisse zu erzielen.

Begründungsmodelle erzeugen zwei Arten von Inhalten als Ausgaben:

Begründungsvervollständigungen
Ausgabevervollständigungen

Beide Fertigstellungen zählen zu Inhalten, die aus dem Modell generiert wurden. Daher tragen sie zu den Token-Limits und Kosten bei, die mit dem Modell verbunden sind. Einige Modelle, z. B. DeepSeek-V4-Pro, könnten mit dem Begründungsinhalt antworten. Andere, wie o1, geben nur die Vervollständigungen aus.

Modelle für schnelles Schlussfolgern

Berücksichtigen Sie Folgendes, wenn Sie Prompts für Begründungsmodelle erstellen:

Verwenden Sie einfache Anweisungen, und vermeiden Sie die Verwendung von Gedankenkettentechniken.
Durch integrierte Begründungsfunktionen sind einfache Zero-Shot-Prompts so effektiv wie komplexere Methoden.
Wenn Sie zusätzlichen Kontext oder Dokumente bereitstellen, z. B. in RAG-Szenarien, kann das Einbeziehen nur der relevantesten Informationen dazu beitragen, dass das Modell seine Antwort nicht zu stark verkompliziert.
Begründungsmodelle können die Verwendung von Systemmeldungen unterstützen. Sie folgen ihnen jedoch möglicherweise nicht so streng wie andere Nicht-Begründungsmodelle.
Berücksichtigen Sie beim Erstellen von Multi-Turn-Anwendungen, dass nur die endgültige Antwort des Modells und nicht der Begründungsinhalt angehängt wird.

Beachten Sie, dass Argumentationsmodelle länger brauchen können, um Antworten zu generieren. Sie verwenden lange Denkensketten, die eine tiefere und strukturiertere Problemlösung ermöglichen. Sie führen auch Selbstüberprüfungen durch, um ihre Antworten zu überprüfen und ihre Fehler zu korrigieren, wodurch sich daraus ergebende selbstreflektierende Verhaltensweisen zeigen.

Feedback

War diese Seite hilfreich?

Last updated on 2026-09-01