Bereitstellen und Verwenden von MAI-Thinking-1 in Microsoft Foundry (Vorschau)

Important

Die in diesem Artikel markierten Elemente (Vorschau) sind aktuell als öffentliche Vorschau verfügbar. Diese Vorschauversion wird ohne Vereinbarung zum Servicelevel bereitgestellt und sollte nicht für Produktionsworkloads verwendet werden. Manche Features werden möglicherweise nicht unterstützt oder sind nur eingeschränkt verwendbar. Weitere Informationen finden Sie unter Zusätzliche Nutzungsbedingungen für Microsoft Azure-Vorschauversionen.

MAI-Thinking-1 (Vorschau) ist ein Grundmodell aus Microsoft für Workloads, die von mehrstufigen Gründen wie Mathematik, Codierung und Unternehmensszenarien abhängen. Das Modell verwendet eine Api für Chatabschlusse, die mit OpenAI SDK-Stil-Chatabschlussmustern kompatibel ist. Um MAI-Thinking-1 zu verwenden, stellen Sie sie in Microsoft Foundry bereit, legen Sie Ihren Foundry-Endpunkt fest, authentifizieren Sie Ihre Anfrage, und rufen Sie den Endpunkt für Chatabschlusse mit Ihrem Bereitstellungsnamen an.

In diesem Artikel erfahren Sie, wie Sie:

Bereitstellen von MAI-Thinking-1 in Microsoft Foundry
Authentifizieren und Aufrufen der Api für Chatabschlusse mithilfe von Microsoft Entra ID oder einem API-Schlüssel
Aufrufen von Tools mit Funktionsaufrufen
Beibehalten des Überlaufzustands von Gründen
Antworten streamen
Häufige Fehler beheben

Voraussetzungen

Bevor Sie beginnen, benötigen Sie Folgendes:

Ein Azure-Abonnement mit einer gültigen Zahlungsmethode. Wenn Sie nicht über ein Azure-Abonnement verfügen, erstellen Sie ein kostenpflichtiges Azure-Konto.
Zugriff auf Microsoft Foundry.
Ein Microsoft Foundry-Projekt in einer unterstützten Bereitstellungsregion. MAI-Thinking-1 ist für die globale Standardbereitstellung verfügbar.

Hinweis

Die PTU-Bereitstellung wird derzeit für MAI-Thinking-1 nicht unterstützt.
Berechtigung zum Erstellen und Verwalten von Modellbereitstellungen. Mit der Rolle "Cognitive Services Contributor " können Sie Modelle bereitstellen. Weitere Informationen finden Sie unter Azure RBAC-Rollen.
Eine Authentifizierungsmethode: Microsoft Entra ID (empfohlen) oder ein API-Schlüssel.
Installieren Sie die erforderlichen Abhängigkeiten, um die Beispiele mit Microsoft Entra ID Authentifizierung auszuführen.
- Python
- JavaScript
- REST
```
pip install openai azure-identity
```
```
npm install openai @azure/identity
```
REST-Beispiele müssen curl installiert und auf PATH.

MAI-Thinking-1 auf einen Blick

Modellname	Modellversion	Bereitstellungstyp	API-Typ
`MAI-Thinking-1` (Vorschau)	01.06.2026	GlobalStandard	Chat-Vervollständigungen

Bereitstellen von MAI-Thinking-1

Um MAI-Thinking-1 (Vorschau) bereitzustellen, befolgen Sie die Anweisungen in Deploy Microsoft Foundry Models im Foundry-Portal, und wählen Sie das MAI-Thinking-1 modell aus, das bereitgestellt werden soll.

Alternativ können Sie das Modell mithilfe des Azure CLI wie im folgenden Code dargestellt bereitstellen:

Ersetzen Sie <ACCOUNT_NAME>, <RESOURCE_GROUP> und <DEPLOYMENT_NAME> durch Ihre Werte.

az cognitiveservices account deployment create \
  --name <ACCOUNT_NAME> \
  --resource-group <RESOURCE_GROUP> \
  --deployment-name <DEPLOYMENT_NAME> \
  --model-name "mai-thinking-1" \
  --model-format Microsoft \
  --model-version 2026-06-01 \
  --sku-name GlobalStandard \
  --sku-capacity 1

Referenz:az cognitiveservices account deployment delete

So listen Sie alle verfügbaren Bereitstellungen für Ihre Ressource auf:

az cognitiveservices account deployment list \
  --resource-group <RESOURCE_GROUP> \
  --name <ACCOUNT_NAME> \
  -o table

Referenz:az cognitiveservices-Kontobereitstellungsliste

Abrufen der Bereitstellungsdetails und Anmeldeinformationen

Sammeln Sie nach der Bereitstellung den Endpunkt, den Bereitstellungsnamen und den API-Schlüssel, den Sie zum Authentifizieren und Weiterleiten Ihrer API-Anforderungen verwenden. Wenn Sie Microsoft Entra ID für REST-Anforderungen verwenden, rufen Sie auch ein Zugriffstoken ab.

Suchen Sie den Endpunkt, den Bereitstellungsnamen und den Schlüssel auf der Registerkarte "Details" Ihrer Bereitstellung im Foundry-Portal oder im Abschnitt "Schlüssel und Endpunkt" Ihrer Ressource im Azure-Portal.
- Endpunkt: Gießereiressourcenendpunkt des Formulars https://<resource-name>.services.ai.azure.com
- Name: Bereitstellungsname – Verwenden Sie diesen model Wert als Wert in Chatabschlussanforderungen.
- Schlüssel: API-Schlüssel für die Verwendung mit API-Schlüsselauthentifizierung. Alternativ können Sie ein Microsoft Entra ID-Token für die Authentifizierung verwenden.
Melden Sie sich bei REST-Anforderungen, die Microsoft Entra ID verwenden, mit dem Azure CLI an, und rufen Sie dann ein Zugriffstoken ab, und legen Sie es als Umgebungsvariable fest:
```
export AZURE_ENTRA_TOKEN=$(az account get-access-token \
  --resource https://cognitiveservices.azure.com \
  --query accessToken \
  --output tsv)
```
Reference:az account get-access-token

Ausführen einer Chat-Vervollständigung

Verwenden Sie die API für Chatabschlusse , um Nachrichten an MAI-Thinking-1 (Vorschau) zu senden. Der model Wert ist Ihr Bereitstellungsname, nicht der zugrunde liegende Modellname.

Legen Sie diese Umgebungsvariablen fest:

export AZURE_ENDPOINT="<your-foundry-resource-endpoint>"
export AZURE_API_KEY="<your-api-key>"
export DEPLOYMENT_NAME="<your-deployment-name>"

Ein Beispiel für einen Endpunktwert ist https://<resource-name>.services.ai.azure.com.

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

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

client = OpenAI(
    base_url=f"{os.environ['AZURE_ENDPOINT']}/mai/v1",
    api_key=token_provider,
)

response = client.chat.completions.create(
    model=os.environ["DEPLOYMENT_NAME"],
    messages=[
        {"role": "user", "content": "Who were the founders of Microsoft?"}
    ],
    max_completion_tokens=32768,
)

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

Um stattdessen einen API-Schlüssel zu verwenden, übergeben Sie ihn über Standardheader:

import os
from openai import OpenAI

client = OpenAI(
    base_url=f"{os.environ['AZURE_ENDPOINT']}/mai/v1",
    api_key="unused",
    default_headers={"api-key": os.environ["AZURE_API_KEY"]},
)

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

const credential = new DefaultAzureCredential();
const { token } = await credential.getToken("https://cognitiveservices.azure.com/.default");

const client = new OpenAI({
  baseURL: `${process.env.AZURE_ENDPOINT}/mai/v1`,
  apiKey: token,
});

const response = await client.chat.completions.create({
  model: process.env.DEPLOYMENT_NAME,
  messages: [
    { role: "user", content: "Who were the founders of Microsoft?" },
  ],
  max_completion_tokens: 32768,
});

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

Um stattdessen einen API-Schlüssel zu verwenden, übergeben Sie ihn über Standardheader:

const client = new OpenAI({
  baseURL: `${process.env.AZURE_ENDPOINT}/mai/v1`,
  apiKey: "unused",
  defaultHeaders: { "api-key": process.env.AZURE_API_KEY },
});

curl "$AZURE_ENDPOINT/mai/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_ENTRA_TOKEN" \
  -d '{
    "model": "'"$DEPLOYMENT_NAME"'",
    "messages": [
      { "role": "user", "content": "Who were the founders of Microsoft?" }
    ],
    "max_completion_tokens": 32768
  }'

Um stattdessen einen API-Schlüssel zu verwenden, ersetzen Sie den Authorization Header durch -H "api-key: $AZURE_API_KEY".

Verwenden von Funktionsaufrufen und -tools

Verwenden Sie MAI-Thinking-1 in agentischen Workflows, die Tools oder Funktionen aufrufen. Nur Funktionstools werden unterstützt. Verwenden Sie Funktionsaufrufe, wenn Ihre Anwendung das Modell benötigt, um ein Tool auszuwählen, strukturierte Argumente bereitzustellen oder mehrere Schritte zu koordinieren.

{
  "model": "<deployment-name>",
  "messages": [
    { "role": "user", "content": "What's the weather in San Francisco today?" }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
          "type": "object",
          "properties": {
            "city": { "type": "string" }
          },
          "required": ["city"]
        }
      }
    }
  ]
}

Beibehalten des Überlaufzustands von Gründen

Um den verschlüsselten Begründungsstatus zu erhalten, legen Sie reasoning_display für jede Anforderung fest encrypted . Bei Festlegung enthält reasoning.encrypted_content die Antwort die Assistant-Nachricht (nicht streaming) oder den endgültigen Datenstromabschnitt (delta.reasoning.encrypted_content). Wenn Sie ihn nicht festlegen, reasoning ist null und es gibt nichts, das sich über Drehungen hinweg tragen lässt.

MAI-Thinking-1 gibt verschlüsselte Gedankenkette mit einer Antwort zurück. Der verschlüsselte Wert ist für Ihre Anwendung undurchsichtig und macht die unformatierte Begründung des Modells nicht verfügbar. Übergeben Sie es wieder an das Modell, wenn eine spätere Wendung in derselben Unterhaltung vorteile von der bereits ausgeführten Begründung des Modells profitiert, z. B. Multi-Turn-Agent-Schleifen und Toolaufrufworkflows. So übergeben Sie den verschlüsselten Begründungsstatus:

Geben Sie den Wert genau so zurück, wie Sie ihn erhalten haben. Alle Änderungen werden ungültig.
Senden Sie die vollständige Assistentennachricht zurück, anstatt sie nach Feld neu zu erstellen.
Überprüfen, decodieren, transformieren, protokollieren oder anzeigen Sie den Wert nicht.
Der Wert zählt zum Kontextfenster, wenn Sie ihn zurücksenden.

Hinweis

Durch die Serialisierung der vollständigen Assistentennachricht wird das verschlüsselte Feld mit Gedankenkette genau wie zurückgegeben beibehalten. Wenn Die SDK-Version das Feld nicht verfügbar macht, behalten Sie das entsprechende Assistentennachrichtenobjekt aus der unformatierten API-Antwort bei.

first_response = client.chat.completions.create(
    model=os.environ["DEPLOYMENT_NAME"],
    messages=[{"role": "user", "content": "Plan a migration in three phases."}],
    max_completion_tokens=32768,
    extra_body={"reasoning_display": "encrypted"},
)

assistant_message = first_response.choices[0].message

follow_up_messages = [
    {"role": "user", "content": "Plan a migration in three phases."},
    assistant_message.model_dump(exclude_none=True),
    {"role": "user", "content": "Expand phase two with risks and mitigations."},
]

follow_up_response = client.chat.completions.create(
    model=os.environ["DEPLOYMENT_NAME"],
    messages=follow_up_messages,
    max_completion_tokens=32768,
)

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

const firstResponse = await client.chat.completions.create({
  model: process.env.DEPLOYMENT_NAME,
  messages: [
    { role: "user", content: "Plan a migration in three phases." },
  ],
  max_completion_tokens: 32768,
  reasoning_display: "encrypted",
});

const assistantMessage = firstResponse.choices[0].message;

const followUpResponse = await client.chat.completions.create({
  model: process.env.DEPLOYMENT_NAME,
  messages: [
    { role: "user", content: "Plan a migration in three phases." },
    assistantMessage,
    { role: "user", content: "Expand phase two with risks and mitigations." },
  ],
  max_completion_tokens: 32768,
});

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

curl "$AZURE_ENDPOINT/mai/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_ENTRA_TOKEN" \
  -d '{
    "model": "'"$DEPLOYMENT_NAME"'",
    "messages": [
      { "role": "user", "content": "Plan a migration in three phases." },
      <assistant message from the previous response, returned unchanged>,
      { "role": "user", "content": "Expand phase two with risks and mitigations." }
    ],
    "max_completion_tokens": 32768,
    "reasoning_display": "encrypted"
  }'

Antworten streamen

Legen Sie stream fest, dass true die Antwort inkrementell empfangen wird, anstatt auf den vollständigen Abschluss zu warten. Streaming ist nützlich für Chatschnittstellen und lange Gründe aufgaben, bei denen Zeit-zu-Erster-Token mehr als die gesamte Latenz wichtig ist.

Wenn das Streaming aktiviert ist, wird die Antwort als Eine Reihe von servergesendeten Ereignissen übermittelt. Jedes Ereignis ist ein chat.completion.chunk Objekt und nicht das einzelne chat.completion Objekt, das von einer nicht gestreamten Anforderung zurückgegeben wird. Die gestreamte Antwort weist die folgenden Merkmale auf:

Jeder Abschnitt enthält die delta inkrementellen Felder für diesen Schritt. Text wird in dem delta.content Feld über aufeinander folgende Blöcke eingetroffen.
Zwischenblöcke, die auf NULL und finish_reason null festgelegt sindusage.
Der endgültige Blocksatz und finish_reason enthält das gefüllte usage Objekt, einschließlich usage.prompt_tokens_details.cached_tokens.
Wenn Sie auf <a0/> festgelegt sind, wird der verschlüsselte Begründungsstatus im endgültigen Block als . reasoning Andernfalls ist null für jeden Block.
Der Datenstrom wird mit einem data: [DONE] Sentinel beendet.

stream = client.chat.completions.create(
    model=os.environ["DEPLOYMENT_NAME"],
    messages=[
        {"role": "user", "content": "Count from 1 to 5, one per line."}
    ],
    max_completion_tokens=32768,
    stream=True,
)

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

const stream = await client.chat.completions.create({
  model: process.env.DEPLOYMENT_NAME,
  messages: [
    { role: "user", content: "Count from 1 to 5, one per line." },
  ],
  max_completion_tokens: 32768,
  stream: true,
});

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

curl "$AZURE_ENDPOINT/mai/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_ENTRA_TOKEN" \
  -N \
  -d '{
    "model": "'"$DEPLOYMENT_NAME"'",
    "messages": [
      { "role": "user", "content": "Count from 1 to 5, one per line." }
    ],
    "max_completion_tokens": 32768,
    "stream": true
  }'

Ein Zwischenabschnitt weist die folgende Form auf:

data: {
  "id": "mai-api-<uuid>",
  "object": "chat.completion.chunk",
  "created": 1785277080,
  "model": "MAI-Thinking-1",
  "choices": [
    {
      "delta": {
        "content": "1\n",
        "role": "assistant",
        "tool_calls": null,
        "reasoning": null,
        "annotations": null
      },
      "index": 0,
      "finish_reason": null
    }
  ],
  "system_fingerprint": "",
  "usage": null
}

Der letzte Teil trägt den Grundzustand, den Endgrund und die Tokenverwendung. Dieses Beispiel zeigt die Antwort auf eine Anforderung, die auf reasoning_displayencrypted. reasoning Andernfalls ist null.

data: {
  "id": "mai-api-<uuid>",
  "object": "chat.completion.chunk",
  "created": 1785277080,
  "model": "MAI-Thinking-1",
  "choices": [
    {
      "delta": {
        "content": null,
        "role": "assistant",
        "tool_calls": null,
        "reasoning": {
          "encrypted_content": "<encrypted-reasoning-blob>",
          "content": null,
          "summary": null
        },
        "annotations": null
      },
      "index": 0,
      "finish_reason": "stop"
    }
  ],
  "system_fingerprint": "",
  "usage": {
    "prompt_tokens": 19,
    "completion_tokens": 76,
    "total_tokens": 95,
    "prompt_tokens_details": { "cached_tokens": 2 }
  }
}

data: [DONE]

Inhaltssicherheit in gestreamten Antworten

Die Inhaltssicherheit gilt für gestreamte Antworten. Eine aufforderung, die durch Eingabesicherheit blockiert wird, schlägt vor dem Start der Generation fehl und gibt HTTP 400 zurück. Die Ausgabesicherheit wird als Antwortdatenströme ausgewertet, sodass die Erzeugung die Mittlere Antwort beenden kann. Mit stream: true, erhält der Client die bisher produzierten Blöcke, gefolgt von einem Terminal SSE-Fehlerereignis, wo error.type = SafetyBlockedError, und dann data: [DONE]. Behandeln Sie eine abgeschnittene Antwort, die als erwarteter Fall in einem Fehlerereignis endet. Bei Nicht-Streaming-Anforderungen gibt ein Ausgabesicherheitsblock HTTP 400 zurück.

Wann man MAI-Thinking-1 verwendet

Verwenden Sie MAI-Thinking-1 (Vorschau) für Workloads, die von tieferer Begründung, längerem Kontext oder bewussterer Planung profitieren. Es eignet sich am besten für Aufgaben, bei denen die Antwortqualität von mehrstufiger Begründung abhängt. Zu den gängigen Anwendungsfällen gehören:

Enterprise-Bereitstellungen: Ein Kontextfenster von 256K, saubere Daten-Provenienz, Funktionsaufrufe und die Möglichkeit, komplexe Anweisungen zu befolgen.
Codierungsworkflows: Lesen von Code, Bearbeiten von Dateien, Ausführen von Tests, Beheben von Fehlern, Beobachten von Fehlern und Wiederherstellen von Zwischenfehlern.
Komplexe Begründungsaufgaben: Quantitatives Denken wie Finanzmodellierung, statistische Analyse, Marktgröße und Prognose.

API-Endpunkte

Nachdem Sie MAI-Thinking-1 (Vorschau) bereitgestellt haben, rufen Sie den Endpunkt für Chatabschlusse in Ihrer Foundry-Ressource auf:

https://<resource-name>.services.ai.azure.com/mai/v1/chat/completions

Zum Authentifizieren benötigen Sie Ihren Ressourcenendpunkt und entweder ein Microsoft Entra ID-Token oder einen API-Schlüssel. Sie finden diese Werte im Abschnitt "Schlüssel und Endpunkt " Ihrer Ressource im Azure-Portal oder auf der Seite "Bereitstellungsdetails" im Foundry-Portal.

Anforderungsparameter

Die API für Chatabschlusse akzeptiert die folgenden Parameter.

Parameter	Type	Erforderlich	Beschreibung
`model`	Schnur	Erforderlich	Ihr Microsoft Findry-Bereitstellungsname.
`messages`	array	Erforderlich	Die Unterhaltungsnachrichten, die an das Modell gesendet werden sollen.
`max_completion_tokens`	integer	Fakultativ	Die maximale Anzahl von generierten Token, einschließlich der Begründungstoken. Die Ausgabe ist auf 64K-Token begrenzt und muss in das verbleibende Kontextbudget passen.
`tools`	array	Fakultativ	Funktionsdefinitionen, die das Modell aufrufen kann. Nur Funktionstools werden unterstützt.
`stream`	Boolescher Wert	Fakultativ	Wenn `true`die Antwort als Server-gesendeter Ereignisdatenstrom von `chat.completion.chunk` Objekten übermittelt wird. Wird standardmäßig auf `false` festgelegt.
`reasoning_display`	Schnur	Fakultativ	Fordern Sie den verschlüsselten Begründungsumschlag in der Antwort an. Legen Sie diesen Wert fest, `encrypted` um für die Assistant-Nachricht zurückzukehren `reasoning.encrypted_content` . Dieser Parameter ist eine MAI-Erweiterung: senden Mit `extra_body` (Python) oder als zusätzliches Feld (JavaScript und REST). Wenn sie weggelassen wird, wird kein Grundumschlag zurückgegeben.

Antwortformat

Eine erfolgreiche Chatabschlussantwort enthält die Assistant-Nachricht in den Antwortoptionen.

Feld	Type	Beschreibung
`choices[].message.content`	Schnur	Die Antwort des Assistenten. Null, wenn das Modell Toolaufrufe zurückgibt.
`choices[].message.tool_calls`	array	Vom Modell angeforderte Funktionstoolaufrufe.
`choices[].message.reasoning.encrypted_content`	Schnur	Opaque Reasoning state returned with the assistant message when `reasoning_display` is set to `encrypted`. Bewahren Sie sie unverändert auf Wendungen auf.
`choices[].finish_reason`	Schnur	Warum die Generation beendet wurde. In der Regel `stop` (normaler Abschluss, einschließlich des Zeitpunkts, an dem die Nachricht Toolaufrufe enthält), `length` (drücken Sie den Tokengrenzwert) oder inhaltsfilter. Überprüfen Sie `choices[].message.tool_calls` , ob Toolaufrufe erkannt werden, anstatt sich auf `finish_reason`diese zu verlassen.
`usage.prompt_tokens_details.cached_tokens`	integer	Die Anzahl der Vom Präfixcache bereitgestellten Eingabeaufforderungstoken.

Das folgende Beispiel zeigt eine Antwort, die einen Toolaufruf enthält.

{
  "id": "<completion-id>",
  "object": "chat.completion",
  "created": 1785277080,
  "model": "<deployment-name>",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "refusal": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"city\":\"San Francisco\"}"
            }
          }
        ]
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 87,
    "completion_tokens": 41,
    "total_tokens": 128,
    "prompt_tokens_details": { "cached_tokens": 0 }
  }
}

Tokenbeschränkungen und Kontextfenster

MAI-Thinking-1 (Vorschau) verfügt über ein Gesamtbudget von 256K pro Anforderung, das lange Kontextaufforderungen und erweiterten Unterhaltungsverlauf unterstützt. Die Ausgabe wird auf 64K-Token oder das verbleibende Kontextbudget nach eingaben begrenzt, je nachdem, was kleiner ist.

Nachrichten und generierte Ausgabeanzahl für dieses Tokenbudget:

Eingabetoken: Die Nachrichten in Ihrer Anforderung zählen zum Eingabetokenbudget.
Ausgabetoken: max_completion_tokens begrenzt die generierte Antwort, bis zur 64K-Ausgabekappe und enthält Begründungstoken.
Summe: Eingabe- und Ausgabetoken müssen in das Kontextfenster von 256K-Token passen. Wenn eine Anforderung das Kontextfenster überschreitet, schlägt sie fehl.

API-Kontingente und -Grenzwerte

MAI-Thinking-1 (Vorschau) weist die folgenden Geschwindigkeitsgrenzwerte auf, die in Anforderungen pro Minute (RPM) und Token pro Minute (TPM) gemessen werden. Die für Sie verfügbare Stufe hängt von Ihrer Abonnement- und Bereitstellungskonfiguration ab.

Bereitstellungstyp	Tarif	TPM	RPM
Globaler Standard	Niedrig (Standard)	0	0
Globaler Standard	Medium	100,000	100
Globaler Standard	High	250,000	250

MAI-Thinking-1 unterstützt die globale Standardbereitstellung. Informationen zu unterstützten Bereitstellungsregionen finden Sie unter "Verfügbarkeit der Region für Foundry Models", die von Azure verkauft werden. Die PTU-Bereitstellung wird derzeit nicht unterstützt.

Troubleshoot

Verwenden Sie die folgende Tabelle, um häufige Fehler und Lösungen zu identifizieren.

Fehler	Mögliche Ursache	Resolution
400 Fehlerhafte Anfrage	Ungültiges Anforderungs-Shape oder nicht unterstützte Parameter, z `max_tokens` . B. anstelle von `max_completion_tokens`. Wird auch zurückgegeben, wenn die Eingabesicherheit die Eingabeaufforderung blockiert.	Überprüfen Sie den Anforderungstext anhand des API-Vertrags, und überprüfen Sie die unterstützten Parameter.
401 Nicht autorisiert	Ungültiger API-Schlüssel, abgelaufenes Token oder fehlender oder falscher Authentifizierungsheader.	Überprüfen Sie Ihre Anmeldeinformationen, den Tokenbereich und den Header (`api-key` für API-Schlüssel, `Authorization: Bearer` für Microsoft Entra ID).
403 Verboten	Authentifiziert, aber nicht erlaubt, auf das angeforderte Modell zuzugreifen.	Überprüfen Des Rollenzuweisungs- und Modellzugriffs.
404 nicht gefunden	Falscher Endpunkt- oder Bereitstellungsname oder eine referenzierte Ressource wurde nicht gefunden.	Überprüfen Sie den Endpunkt- und Bereitstellungsnamen in Microsoft Foundry.
422 Nicht verarbeitete Entität	Fehler bei der API-Schemaüberprüfung der Anforderung.	Korrigieren Sie den Anforderungstext entsprechend dem API-Schema.
429 – Zu viele Anforderungen	Das Ratenlimit wurde überschritten.	Wiederholen Sie den Vorgang mit "Backoff", oder fordern Sie eine Kontingenterhöhung an, falls verfügbar.
500: Interner Serverfehler	Serverseitiger Fehler oder Fehlkonfiguration.	Wiederholen Sie den Vorgang mit "Backoff". Wenn das Problem weiterhin besteht, überprüfen Sie den Dienststatus und den Supportleitfaden.
502 Ungültiges Gateway	Upstream-Fehler vom Agent Orchestrator oder Rückschluss-Back-End.	Wiederholen Sie den Vorgang mit "Backoff".
503 Dienst nicht verfügbar	Eine Abhängigkeit, z. B. der Sicherheitsdienst, ist vorübergehend nicht verfügbar.	Wiederholen Sie den Vorgang mit "Backoff".

Schreiben effektiver Aufforderungen zum Erstellen von Gründen

Stellen Sie das Modell aus Gründen schwerer Vorgänge mit dem Ziel, kontext, einschränkungen und dem erwarteten Ausgabeformat bereit. Empfohlene Muster:

Geben Sie das Ziel klar an.
Beziehen Sie den relevanten Kontext ein.
Stellen Sie Einschränkungen bereit, z. B. Benutzergruppen, Format, Länge oder Geschäftsregeln.
Bitten Sie um präzise abschließende Antworten, wenn Sie keine detaillierte Erklärung benötigen.

Das folgende Beispiel zeigt eine gut strukturierte Eingabeaufforderung.

You are helping someone plan a weekend trip.

Goal: Suggest a simple two-day itinerary for a first-time visitor to Seattle.

Context: The visitor enjoys food, walking, and being outdoors, and is traveling on a modest budget.

Output: Return a prioritized list with:
- Activity
- Why it's worth doing
- Rough time of day
- Approximate cost
- One tip

Verantwortungsvolle KI-Überlegungen

Bevor Sie MAI-Thinking-1 (Vorschau) in einer Anwendung verwenden, bewerten Sie das Modell für Ihr beabsichtigtes Szenario. Befolgen Sie die folgenden empfohlenen Methoden:

Überprüfen Sie das Modellverhalten bei realistischen Eingabeaufforderungen.
Testen Sie aufgabenspezifische Qualität, Sicherheit und Zuverlässigkeit.
Verwenden Sie die menschliche Überprüfung für workflows mit hohem Einfluss.
Protokollieren und überwachen Sie Fehler gemäß Ihren Anwendungsanforderungen.
Wenden Sie geeignete Sicherheits- und Missbrauchsüberwachung für Inhalte an.

Microsoft Gießerei-Bildschirmanforderungen mit Eingabesicherheit und Bildschirmantworten mit Ausgabesicherheit. Ausführliche Informationen dazu, wie sich blockierte Eingabeaufforderungen und -antworten verhalten, einschließlich Streaminganforderungen, finden Sie unter Inhaltssicherheit in gestreamten Antworten.

Feedback

War diese Seite hilfreich?

Last updated on 2026-08-14