Az Azure OpenAI Responses API használata

Az Azure OpenAI Responses API használatával állapotalapú, többfordulós válaszokat hozhat létre. Egyetlen egységes felületen egyesíti a csevegések befejezéséből és az Assistants API-ból származó képességeket. A Responses API támogatja a computer-use-preview modellt, amely a számítógép használatát is támogatja.

Előfeltételek

  • Üzembe helyezett Azure OpenAI-modell.
  • Hitelesítési módszer:
    • API-kulcs (például AZURE_OPENAI_API_KEY), vagy
    • Microsoft Entra ID (ajánlott).
  • Telepítse a nyelvhez tartozó ügyfélkódtárat:
    • Python:pip install openai azure-identity
    • .NET: dotnet add package OpenAI és dotnet add package Azure.Identity
    • JavaScript/TypeScript: npm install openai @azure/identity
    • Java: com.openai:openai-java és com.azure:azure-identity hozzáadása a projekthez.
  • REST-példák esetén állítsa be AZURE_OPENAI_API_KEY (API-kulcsfolyamat) vagy AZURE_OPENAI_AUTH_TOKEN (Microsoft Entra ID folyamat).

Támogatott régiók

A cikkben szereplő példák futtatása előtt győződjön meg arról, hogy az erőforrás-régió támogatja a Responses API-t. A legújabb funkciók eléréséhez a v1 API-ra van szükség. További részletekért tekintse meg az API-verzió életciklusát. Az Foundry Agent Service regionális támogatásáról a regionális rendelkezésre állási táblában olvashat. A Responses API jelenleg a következő régiókban érhető el:

  • australiaeast
  • brazilsouth
  • canadacentral
  • Kelet-Kanada
  • központi
  • eastus
  • eastus2
  • francecentral
  • Németország nyugat-közép
  • italynorth
  • japaneast
  • japanwest
  • koreacentral
  • northcentralus
  • norwayeast
  • lengyelországcentral
  • southafricanorth
  • southcentralus
  • délkelet-ázsia
  • Dél-India
  • spaincentral
  • swedencentral
  • SvájcNorth
  • switzerlandwest
  • uaenorth
  • uksouth
  • ukwest
  • USA nyugati középső régiója
  • Nyugat-Európa
  • westus
  • westus2
  • westus3

Támogatott modellek

A Responses API a következő modelleket támogatja:

  • gpt-5.6-sol (Verzió: 2026-07-09)
  • gpt-5.6-terra (Verzió: 2026-07-09)
  • gpt-5.6-luna (Verzió: 2026-07-09)
  • gpt-chat-latest(Verziók: 2026-06-24, 2026-05-28) 2026-05-05
  • gpt-5.5 (Verzió: 2026-04-24)
  • gpt-5.4-nano (Verzió: 2026-03-17)
  • gpt-5.4-mini (Verzió: 2026-03-17)
  • gpt-5.4-pro (Verzió:2026-03-05)
  • gpt-5.4 (Verzió:2026-03-05)
  • gpt-5.3-chat (Verzió: 2026-03-03)
  • gpt-5.3-codex (Verzió: 2026-02-24)
  • gpt-5.2-codex (Verzió: 2026-01-14)
  • gpt-5.2 (Verzió: 2025-12-11)
  • gpt-5.2-chat (Verzió: 2025-12-11)
  • gpt-5.2-chat (Verzió: 2026-02-10)
  • gpt-5.1-codex-max (Verzió: 2025-12-04)
  • gpt-5.1 (Verzió: 2025-11-13)
  • gpt-5.1-chat (Verzió: 2025-11-13)
  • gpt-5.1-codex (Verzió: 2025-11-13)
  • gpt-5.1-codex-mini (Verzió: 2025-11-13)
  • gpt-5-pro (Verzió: 2025-10-06)
  • gpt-5-codex (Verzió: 2025-09-11)
  • gpt-5 (Verzió: 2025-08-07)
  • gpt-5-mini (Verzió: 2025-08-07)
  • gpt-5-nano (Verzió: 2025-08-07)
  • gpt-5-chat (Verzió: 2025-08-07)
  • gpt-5-chat (Verzió: 2025-10-03)
  • gpt-5-codex (Verzió: 2025-09-15)
  • gpt-4o(Verziók: 2024-11-20, 2024-08-06) 2024-05-13
  • gpt-4o-mini (Verzió: 2024-07-18)
  • computer-use-preview
  • gpt-4.1 (Verzió: 2025-04-14)
  • gpt-4.1-nano (Verzió: 2025-04-14)
  • gpt-4.1-mini (Verzió: 2025-04-14)
  • gpt-image-1 (Verzió: 2025-04-15)
  • gpt-image-1-mini (Verzió: 2025-10-06)
  • gpt-image-1.5 (Verzió: 2025-12-16)
  • o1 (Verzió: 2024-12-17)
  • o3-mini (Verzió: 2025-01-31)
  • o3 (Verzió: 2025-04-16)
  • o4-mini (Verzió: 2025-04-16)

Nem minden modell érhető el minden támogatott régióban. Ellenőrizze a modellrégió rendelkezésre állását a modellek oldalán . A kérelem- és válaszparaméterek teljes készletét a Responses API referenciadokumentációjában találja.

Megjegyzés

Jelenleg nem támogatott:

  • Képgenerálás többfordulós szerkesztéssel és streameléssel.
  • A képek nem tölthetők fel fájlként, és nem hivatkozhatnak rá bemenetként.

Az alábbiakkal kapcsolatban ismert probléma merült fel:

  • A PDF bemeneti fájlként már támogatott, de a fájlfeltöltés céljának user_data beállítása jelenleg nem támogatott.
  • Teljesítményproblémák a háttér mód streamelésekor. Microsoft dolgozik a probléma megoldásán.

Szöveges válasz létrehozása

Egyszerű szöveges válasz létrehozása a Responses API használatával. Cserélje le a(z) YOUR-RESOURCE-NAME és MODEL_NAME elemeket a telepítési értékeire.

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

# API key authentication
client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.create(
    model="MODEL_NAME",
    input="This is a test."
)
print(response.model_dump_json(indent=2))

# Microsoft Entra ID authentication (recommended)
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.responses.create(
    model="MODEL_NAME",
    input="This is a test."
)
print(response.model_dump_json(indent=2))

Példa válasz

{
  "id": "resp_67cb32528d6881909eb2859a55e18a85",
  "created_at": 1741369938.0,
  "output_text": "Great! How can I help you today?",
  ...
}

Válasz lekérése

Válasz lekérése az azonosítója alapján egy korábbi Responses API-hívásból.

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

# API key authentication
client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.retrieve("<response_id>")
print(response.model_dump_json(indent=2))

# Microsoft Entra ID authentication
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.responses.retrieve("<response_id>")
print(response.model_dump_json(indent=2))

Példa válasz

{
  "id": "resp_67cb61fa3a448190bcf2c42d96f0d1a8",
  "output_text": "Hello! How can I assist you today?",
  ...
}

Válasz törlése

Alapértelmezés szerint a válaszadatok 30 napig maradnak meg. Törölje a tárolt választ azonosító alapján.

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

# API key authentication
client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.delete("<response_id>")
print(response)

# Microsoft Entra ID authentication
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.responses.delete("<response_id>")
print(response)

Válaszok összeláncolása

A lánc úgy fordul elő, hogy átadja az előző válaszazonosítót a következőnek previous_response_id: .

import os
from openai import OpenAI

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

first_response = client.responses.create(
    model="MODEL_NAME",
    input="Define catastrophic forgetting."
)

second_response = client.responses.create(
    model="MODEL_NAME",
    previous_response_id=first_response.id,
    input="Explain it for a college freshman."
)

print(second_response.output_text)

Válaszok manuális láncolása

Másik lehetőségként manuálisan is továbbíthatja a kimeneti elemeket a következő kérelemben.

import os
from openai import OpenAI

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

inputs = [{"type": "message", "role": "user", "content": "Define and explain the concept of catastrophic forgetting?"}] 
  
response = client.responses.create(  
    model="gpt-4o",  # replace with your model deployment name  
    input=inputs  
)  
  
inputs += response.output

inputs.append({"role": "user", "type": "message", "content": "Explain this at a level that could be understood by a college freshman"}) 
               

second_response = client.responses.create(
  model="MODEL_NAME",
    input=inputs
)

print(second_response.model_dump_json(indent=2))

Válasz tömörítése

A tömörítés csökkenti a bemeneti környezetet, és megőrzi az alapvető állapotot a későbbi fordulatokhoz.

import os
from openai import OpenAI

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

compacted = client.responses.compact(
  model="MODEL_NAME",
  input=[
    {"role": "user", "content": "Create a simple landing page for a dog cafe."},
    {
      "id": "msg_001",
      "type": "message",
      "status": "completed",
      "role": "assistant",
      "content": [{"type": "output_text", "text": "..."}],
    },
  ]
)

follow_up = client.responses.create(
  model="MODEL_NAME",
  input=[*compacted.output, {"role": "user", "content": "Add a booking form."}]
)
print(follow_up.output_text)

Az elemek visszaadásával történő tömörítés

A korábbi kérésekből visszaadott összes elemet tömörítheti, például az érvelést, az üzenetet, a függvényhívást stb.

curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/compact \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
        "model": "MODEL_NAME",
        "input": [
          {
            "role"   : "user",
            "content": "Create a simple landing page for a dog petting café."
          },
          {
            "id": "msg_001",
            "type": "message",
            "status": "completed",
            "content": [
              {
                "type": "output_text",
                "annotations": [],
                "logprobs": [],
                "text": "Below is a single file, ready-to-use landing page for a dog petting café:..."
              }
            ],
            "role": "assistant"
          }
        ]
    }'

# Use the compacted output as input for the next turn.
next_response = client.responses.create(
  model="MODEL_NAME",
  input=[*compacted.output, {"role": "user", "content": "Add opening hours."}],
)
print(next_response.output_text)

Tömörítés az előző válaszazonosító használatával

A tömörítéshez használhat egy korábbi válaszazonosítót is.

initial_response = client.responses.create(
  model="MODEL_NAME",
  input="What is the size of France?"
)

compacted_response = client.responses.compact(
  model="MODEL_NAME",
  previous_response_id=initial_response.id
)

follow_up_response = client.responses.create(
  model="MODEL_NAME",
  input=[
    *compacted_response.output,
    {"role": "user", "content": "What is the capital?"}
  ]
)
print(follow_up_response.output_text)

Kiszolgálóoldali tömörítés

A kiszolgálóoldali tömörítést közvetlenül a Válaszok (POST /responsesvagy client.responses.create) nézetben is használhatja egy context_managementbeállítássalcompact_threshold.

  • Amikor a kimeneti jogkivonatok száma túllépi a konfigurált küszöbértéket, a Responses API automatikusan tömörítést futtat.
  • Ebben a módban nem kell külön hívnia /responses/compact .
  • A válasz tartalmaz egy titkosított tömörítési elemet.
  • A kiszolgálóoldali tömörítés akkor működik, ha a store=false értéket állítja be a válaszok létrehozási kérelmeiben.

A tömörítési elem továbbviszi a lényeges korábbi állapotot, és kevesebb token használatával folytat érvelést a következő fordulóban. Átlátszatlan, és nem emberi olvasásra szolgál.

Ha állapot nélküli bemeneti tömbláncolást használ, a szokásos módon fűzze hozzá a kimeneti elemeket. Ha használja previous_response_id, minden egyes turnön csak az új felhasználói üzenetet adja át. Mindkét mintában a tömörítési elem hordozza a következő ablakhoz szükséges környezetet.

Tipp

Miután hozzáadja a kimeneti elemeket az előző bemeneti elemekhez, a legutóbbi kompakt elem előtti elemeket elvetheti, hogy a kérések kisebbek maradjanak, és csökkenjen a hosszú késleltetés. A legújabb tömörítési elem hordozza a beszélgetés folytatásához szükséges környezeti információt. Ha previous_response_id láncolást használ, ne metsszen manuálisan.

Flow

  1. Hívjon responses a szokásos módon. Add hozzá context_management-t a compact_threshold-hoz a kiszolgálóoldali tömörítés engedélyezéséhez.
  2. Ha a kimenet túllépi a küszöbértéket, a szolgáltatás tömörítést indít el, kibocsát egy tömörítési elemet a kimeneti adatfolyamban, és a következtetés folytatása előtt megszűri a környezetet.
  3. Folytassa a beszélgetést az alábbi minták egyikével:
    1. Állapot nélküli bemeneti tömb láncolása: a kimeneti elemek hozzáfűzése a következő bemeneti tömbhöz, beleértve a tömörítési elemeket is.
    2. previous_response_id láncolás: csak az új felhasználói üzenet átadása fordulónként, és a legújabb válaszazonosító továbbítása.

Példa

conversation = [
  {
    "type": "message",
    "role": "user",
    "content": "Let's begin a long coding task.",
  }
]

while keep_going:
  response = client.responses.create(
    model="MODEL_NAME",
    input=conversation,
    store=False,
    context_management=[{"type": "compaction", "compact_threshold": 200000}],
  )

  conversation.append(
    {
      "type": "message",
       "role": "user",
      "content": get_next_user_input(),
    }
  )

Streaming

A válasz generálás közbeni továbbításához állítsa be a(z) stream=true értéket. A szolgáltatás inkrementális eseményeket küld, amelyeket a kimenet tokenenkénti megjelenítéséhez dolgozhat fel.

import os
from openai import OpenAI

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

stream = client.responses.create(
    model="MODEL_NAME",
    input="Summarize Azure OpenAI Responses API in one sentence.",
    stream=True,
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="")

Streamelés közben, ha hiba történik a stream közepén, a rendszer belső újrapróbálkozással próbálja megoldani a hibát. Ha a kérés továbbra is sikertelen, a szolgáltatás helyreállíthatatlan hibába ütközik. Ezekben az esetekben a HTTP-válaszkód 200 (sikeres), de a streamben lévő hibaesemény részletes információkat tartalmaz a középáramú hibákról.

A kiszolgáló a következő hibatípusokat adja vissza:

Hibatípus Lefordítható
server_error Visszatérési kód 500
too_many_requests Visszatérési kód 429
forbidden Visszatérési kód 403
user_error Visszatérési kód 400

Példa hibaesemény:

{
  "type": "error",
  "error": {
    "type": "too_many_requests",
    "code": "no_capacity",
    "headers": {
      "skip-error-remapping": "true"
    },
    "message": "The system is currently experiencing high demand and cannot process your request. Your request exceeds the maximum usage size allowed during peak load. For improved capacity reliability, consider switching to Provisioned Throughput.",
    "param": null
  }
}

Az alkalmazásoknak észlelniük kell ezeket a hibákat, és kecsesen le kell állítaniuk vagy újra kell indítaniuk a streamelést. A sikertelen streamelési válaszok során létrehozott jogkivonatokért nem számítunk fel díjat.

Függvényhívás

A Responses API támogatja a függvényhívást.

import os
import json
from openai import OpenAI

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

response = client.responses.create(
    model="MODEL_NAME",
    tools=[
        {
            "type": "function",
            "name": "get_weather",
            "description": "Get weather for a location",
            "parameters": {
                "type": "object",
                "properties": {"location": {"type": "string"}},
                "required": ["location"],
            },
        }
    ],
    input="What is the weather in San Francisco?",
)

tool_outputs = []
for item in response.output:
    if item.type == "function_call" and item.name == "get_weather":
        args = json.loads(item.arguments)
        weather = {"location": args["location"], "temperature": "70 F"}
        tool_outputs.append(
            {
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(weather),
            }
        )

final_response = client.responses.create(
    model="MODEL_NAME",
    previous_response_id=response.id,
    input=tool_outputs,
)

print(final_response.output_text)

Védőkorlátok és tartalomszűrés kezelése

A védőkorlátok (tartalomszűrők) az üzembe helyezés szintjén vannak alkalmazva, és automatikusan futnak minden Responses API-híváson, így védik az elküldött bemenetet és a modell által generált kimenetet is. A védőkorlátokat külön konfigurálja. További információ: Védőkorlátok és vezérlők konfigurálása. Ez a szakasz bemutatja, hogyan észlelheti és kezelheti a védőkorlátok eredményeit a Válaszok API meghívásakor.

A Responses API a védelmi korlátok eredményeit másként jeleníti meg, mint a csevegésbefejezések. A chat completionök által visszaadott prompt_filter_results és content_filter_results mezők helyett a válaszobjektum egy felső szintű content_filters tömböt tartalmaz. Minden bejegyzés egy szűrőeredményt ír le.

Field Leírás
blocked Azt jelzi, hogy a tartalom le lett-e tiltva.
source_type Az eredmény a prompt (bemenetre) vagy a completion (kimenetre) vonatkozik-e.
content_filter_results A kategóriák eredményei, például hate, sexual, violence és self_harm súlyossági szintekkel, valamint az opcionális kategóriák, például jailbreak, indirect_attack, protected_material_text és protected_material_code.
content_filter_offsets Azok a karaktereltolások, amelyekre az eredmény vonatkozik.

Megjegyzés

A content_filters tömb egy Microsoft Foundry-bővítmény, amely nem része az alap OpenAI-válaszséma, így az SDK-k nem fednek fel gépelt tulajdonságot. Olvassa el nyers vagy extra mezőként, ahogy az alábbi példákban is látható.

Blokkolt bemenet észlelése

Ha a védőkorlátok blokkolják a bemenetet, az API HTTP 400-es hibát ad vissza a kóddal content_filter. Fogja el ezt a hibát, hogy a blokkolt promptokat megfelelően kezelhesse.

import os
from openai import OpenAI, BadRequestError

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

# A blocked prompt raises BadRequestError with the code "content_filter"
try:
    response = client.responses.create(
        model="MODEL_NAME",
        input="This is a test."
    )
    print(response.output_text)
except BadRequestError as error:
    if error.code == "content_filter":
        print("The prompt was blocked by a guardrail.")
    else:
        raise

Védelmi megjegyzések olvasása

Ha egy kérés sikeres, olvassa el a content_filters tömböt a válaszból, és vizsgálja meg a biztonsági korlát eredményeit a bemenet és a kimenet szempontjából.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.create(
    model="MODEL_NAME",
    input="This is a test."
)

# content_filters is an Azure extension, so read it from model_extra
content_filters = response.model_extra.get("content_filters", [])
for result in content_filters:
    print(f"Source: {result['source_type']}, Blocked: {result['blocked']}")

A védőkorlátok kategóriáival és súlyossági szintjével kapcsolatos további információkért tekintse meg a Védőkorlátok áttekintését és a Széljegyzetek használatát ismertető témakört.

Kódértelmező

A Kódértelmező eszköz lehetővé teszi, hogy a modellek biztonságos, védőfalas környezetben írjanak és hajtsanak végre Python kódot. Számos speciális feladatot támogat, többek között a következőket:

  • Fájlok feldolgozása változatos adatformátumokkal és struktúrákkal
  • Adatokkal és vizualizációkkal (például grafikonokkal) kapcsolatos fájlok létrehozása
  • A problémák megoldásához iteratív módon írhat és futtathat kódot – a modellek hibakeresést végezhetnek, és újrapróbálkozhatnak a kódot a sikeres működésig
  • A támogatott modellek (például o3, o4-mini) vizuális érvelésének javítása az olyan képátalakítási műveletek engedélyezésével, mint a körülvágás, nagyítás és forgatás.
  • Ez az eszköz különösen hasznos adatelemzést, matematikai számítást és kódgenerálást igénylő forgatókönyvekhez.
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{
        "model": "MODEL_NAME",
        "tools": [
            { "type": "code_interpreter", "container": {"type": "auto"} }
        ],
        "instructions": "You are a personal math tutor. When asked a math question, write and run code using the python tool to answer the question.",
        "input": "I need to solve the equation 3x + 11 = 14. Can you help me?"
    }'

import os
from openai import OpenAI

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

response = client.responses.create(
    model="MODEL_NAME",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions="You are a math tutor. Write and run Python code to solve math problems.",
    input="Solve 3x + 11 = 14."
)

print(response.output_text)

Containers

Fontos

A Code Interpreter többletköltségeket számol fel az Azure OpenAI használat token alapú díjai mellett. Ha a Responses API egyszerre két különböző szálon hívja meg a Kódértelmezőt, két kódértelmező-munkamenet jön létre. Minden munkamenet alapértelmezés szerint 1 órán keresztül aktív, 20 perces tétlenségi időtúllépéssel.

A Kódértelmező eszközhöz tárolóra van szükség – egy teljesen tesztkörnyezetbe helyezett virtuális gépre, ahol a modell végrehajthatja Python kódot. A tárolók tartalmazhatnak a végrehajtás során létrehozott feltöltött fájlokat vagy fájlokat.

Tároló létrehozásához adja meg a "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } -t az eszköz konfigurációjában, amikor új Válasz objektumot hoz létre. Ez automatikusan létrehoz egy új tárolót, vagy újra felhasznál egy aktív tárolót egy korábbi code_interpreter_call a modell környezetében. Az API kimenetében a code_interpreter_call tartalmazni fogja a létrehozott container_id elemet. Ez a tároló lejár, ha 20 percig nem használják.

A következő fájlkorlátok érvényesek:

  • A kérések legfeljebb 50 fájlazonosítót tartalmazhatnak.
  • A tárolók összesen legfeljebb 1000 fájlt tartalmazhatnak, beleértve a kódértelmező által létrehozott bemeneti fájlokat és fájlokat is.

Fájlbemenetek és kimenetek

A Kódértelmező futtatásakor a modell létrehozhatja a saját fájljait. Ha például arra kéri, hogy hozzon létre egy rajzot, vagy hozzon létre egy CSV-t, az közvetlenül a tárolón hozza létre ezeket a lemezképeket. Ezeket a fájlokat a következő üzenet széljegyzeteiben fogja idézni.

A modell bemenetében lévő fájlok automatikusan feltöltődnek a tárolóba. Nem kell explicit módon feltöltenie a tárolóba.

Támogatott fájlok

Fájlformátum MIME-típus
.c szöveg/x-c
.cs text/x-csharp
.cpp szöveg/x-c++
.csv szöveg/csv
.doc application/msword
.docx application/vnd.openxmlformats-officedocument.wordprocessingml.document
.html szöveg/html
.java text/x-java
.json alkalmazás/json
.md szöveg/markdown
.pdf alkalmazás/pdf
.php text/x-php
.pptx application/vnd.openxmlformats-officedocument.presentationml.presentation
.py text/x-python
.py text/x-script.python
.rb szöveg/x-ruby
.tex szöveg/x-tex
.txt szöveg/egyszerű
.css szöveg/css
.js text/JavaScript
.sh application/x-sh
.ts application/TypeScript
.csv alkalmazás/csv
.jpeg kép/jpeg
.jpg kép/jpeg
.gif kép/gif
.pkl application/octet-stream
.png kép/png
.tar alkalmazás/x-tar
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
.xml application/xml vagy "text/xml"
.zip alkalmazás/zip

Bemeneti elemek listázása

Kérje le a válaszba küldött bemeneti elemeket. Ez a teljes beszélgetési környezet vizsgálatához hasznos, beleértve a modell által hozzáadott elemeket (például függvényhívásokat vagy tömörítési elemeket).

import os
from openai import OpenAI

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

items = client.responses.input_items.list("<response_id>")
print(items.model_dump_json(indent=2))

Példa válasz

{
  "object": "list",
  "data": [
    {
      "id": "msg_...",
      "type": "message",
      "role": "user",
      "content": [{"type": "input_text", "text": "This is a test."}]
    }
  ]
}

Képbemenet

A látást lehetővé tevő modellek a szöveg mellett képeket is képesek értelmezni. Felismerhetik a képeken található objektumokat, alakzatokat, színeket és textúrákat, valamint olvasható szövegeket, a jelen cikk későbbi részében felsorolt korlátozásokra is figyelemmel.

A rendszerképet az alábbi módokon adhatja meg a kérések bemeneteként:

  • A képfájl teljes elérési URL-címe
  • Base64-kódolású adat URI
  • A Files API-val létrehozott fájlazonosító

Kép URL-je

Hivatkozás nyilvános URL-címen tárolt képre. A modell lekéri a képet, és a bemeneti tartalom részeként szerepelteti.

import os
from openai import OpenAI

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

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "What is in this image?"},
                {"type": "input_image", "image_url": "<image_url>"}
            ]
        }
    ]
)

print(response.output_text)

Base64 kódolású rendszerkép

Kép beágyazott küldése a bájtok base64-es adat URI-ként való kódolásával. Ezt a mintát akkor használja, ha a rendszerkép nem nyilvános URL-címen van tárolva, vagy ha el szeretné kerülni a további hálózati lekéréseket.

import base64
import os
from openai import OpenAI

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

with open("path_to_your_image.jpg", "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "What is in this image?"},
                {"type": "input_image", "image_url": f"data:image/jpeg;base64,{base64_image}"}
            ]
        }
    ]
)

print(response.output_text)

Fájlazonosító

Töltsön fel egy képet a Files API használatával purpose="vision", majd hivatkozzon a kérésben szereplő visszaadott fájlazonosítóra. Ez a módszer akkor hasznos, ha ugyanazt a lemezképet több kérelemben is újra szeretné használni anélkül, hogy a bájtokat újra el szeretné küldeni.

import os
from openai import OpenAI

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

def create_file(file_path):
    with open(file_path, "rb") as file_content:
        result = client.files.create(
            file=file_content,
            purpose="vision",
        )
        return result.id

file_id = create_file("path_to_your_image.jpg")

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "What is in this image?"},
                {"type": "input_image", "file_id": file_id},
            ],
        }
    ],
)

print(response.output_text)

Képbemeneti követelmények

Az alábbi táblázat a képbemenetek támogatott fájltípusait sorolja fel.

Fájltípus MIME-típus
PNG image/png
JPEG image/jpeg
WebP image/webp
Nem animált GIF image/gif

Egyetlen kérelemben legfeljebb 100 képet vehet fel. Minden egyes képfájlnak 50 MB alatt kell lennie, és a kérelemben szereplő összes kép együttes méretének is 50 MB alatt kell lennie.

A képeknek meg kell felelniük az alábbi további követelményeknek:

  • A képnek relevánsnak kell lennie a kérdés szempontjából; a modell nem kapcsolódó vizualizációs tartalmakhoz készült.
  • A képek nem tartalmazhatnak olyan káros vagy bizalmas tartalmakat, amelyek megsértik a tartalomszabályzatokat.
  • A képfájlok nem lehetnek sérültek vagy olvashatatlanok. Ha a modell nem tud feldolgozni egy képet, a kérés meghiúsul.

Képrészletszint kiválasztása

Az egy detail tartalomrészen lévő input_image tulajdonsággal szabályozhatja, hogyan dolgozza fel a modell a képet. Az alacsonyabb részletesség kevesebb tokent használ, és gyorsabb, míg a magasabb részletesség több tokent használ, de lehetővé teszi, hogy a modell finomabb jellemzőket is felismerjen.

{
  "type": "input_image",
  "image_url": "<image_url>",
  "detail": "high"
}

Az alábbi táblázat az egyes részletszinteket ismerteti.

Részletezési szint Leírás
low A modell a kép alacsonyabb felbontású verzióját használja. Ez a beállítás használja a legkevesebb tokent, és ez adja a leggyorsabb választ, de előfordulhat, hogy a modell nem veszi észre az apró részleteket.
high A modell a kép egy nagyobb felbontású verzióját használja. Ez a beállítás finomabb részleteket ragad meg, de több tokent használ, és tovább tart, mire válaszol.
auto Az alapértelmezett érték. A modell a kép és a kérdés alapján kiválasztja a megfelelő részletességi szintet.

Képbemenet korlátozásai

A látásra képes modellekre a következő korlátozások vonatkoznak:

  • Orvosi képek: A modell nem alkalmas speciális orvosi képek, például CT-vizsgálatok értelmezésére, és nem ajánlott orvosi tanácsadásra használni.
  • Nem angol nyelvű szöveg: Előfordulhat, hogy a modell nem optimálisan működik a nem latin betűs , például japán vagy koreai betűket tartalmazó képek kezelésekor.
  • Kis szöveg: A kép szövegének nagyítása az olvashatóság javítása érdekében, de a fontos részletek körülvágásának elkerülése érdekében.
  • Forgatás: Előfordulhat, hogy a modell félreértelmezi az elforgatott vagy fejjel lefelé írt szöveget és képeket.
  • Vizuális elemek: Előfordulhat, hogy a modell gráfokkal vagy szöveggel küzd, ahol a színek és a stílusok (például egyszínű, szaggatott vagy pontozott vonalak) eltérőek.
  • Térbeli érvelés: A modellnek nehézséget okoz a pontos térbeli honosítást igénylő feladatok, például a sakkpozíciók azonosítása.
  • Pontosság: Előfordulhat, hogy a modell bizonyos esetekben helytelen leírásokat vagy feliratokat hoz létre.
  • Képalakzat: A modellnek nehézségei vannak a panoráma- és halszemképekkel.
  • Metaadatok és átméretezés: A modell nem dolgozza fel az eredeti fájlneveket vagy metaadatokat, és a rendszer átméretezi a képeket az elemzés előtt, ami hatással van az eredeti dimenziókra.
  • Számolás: A modell hozzávetőleges számokat adhat a képeken lévő objektumokhoz.
  • CAPTCHA-k: Biztonsági okokból egy olyan rendszer van érvényben, amely blokkolja a CAPTCHA-k beküldését.

Fájlbemenet

A látási képességekkel rendelkező modellek támogatják a PDF-bemenetet. A PDF-fájlok base64-kódolású adatokként vagy fájlazonosítókként is megadhatóak. A PDF-tartalom értelmezésének segítése érdekében a modell kontextusában a kinyert szöveg és az egyes oldalak képe is megjelenik. Ez akkor hasznos, ha a fő információkat diagramokon vagy nem szöveges tartalmakon keresztül továbbítják.

Megjegyzés

  • Az összes kinyert szöveg és kép a modell környezetébe kerül. Győződjön meg arról, hogy tisztában van azzal, hogy a PDF-fájlok bemenetként való használata milyen hatással van a díjszabásra és a tokenek használatára.
  • Egyetlen API-kérelemben több fájlt is megadhat, de mindegyik fájlnak 50 MB alatt kell lennie. A kérelem összes fájljának összesített korlátja 50 MB.
  • Csak a szöveg- és képbemeneteket támogató modellek fogadhatják el bemenetként a PDF-fájlokat.
  • Az egyik purposeuser_data jelenleg nem támogatott. Ideiglenes áthidaló megoldásként be kell állítania a célt a következőre assistants: .

PDF konvertálása Base64-be és elemzés

Beágyazott PDF-fájl küldése a bájtok base64-es adat URI-ként való kódolásával. A modell megkapja a kinyert szöveget és az egyes oldalak renderelt képét is.

import base64
import os
from openai import OpenAI

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

with open("PDF-FILE-NAME.pdf", "rb") as f:
    base64_string = base64.b64encode(f.read()).decode("utf-8")

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "filename": "PDF-FILE-NAME.pdf",
                    "file_data": f"data:application/pdf;base64,{base64_string}",
                },
                {"type": "input_text", "text": "Summarize this PDF."},
            ],
        },
    ]
)

print(response.output_text)

PDF feltöltése és elemzése

Töltse fel a PDF-fájlt a következővel purpose="assistants": . Az egyik purposeuser_data jelenleg nem támogatott.

import os
from openai import OpenAI

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

file = client.files.create(
    file=open("nucleus_sampling.pdf", "rb"),
    purpose="assistants"
)

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_file", "file_id": file.id},
                {"type": "input_text", "text": "Summarize this PDF."},
            ],
        },
    ]
)

print(response.output_text)

Távoli MCP-kiszolgálók használata

A modell képességeit úgy bővítheti, hogy távoli Model Context Protocol (MCP) kiszolgálókon üzemeltetett eszközökhöz csatlakoztatja. Ezeket a kiszolgálókat fejlesztők és szervezetek tartják karban, és olyan eszközöket tehetnek közzé, amelyeket az MCP-kompatibilis ügyfelek, például a Responses API érhetnek el.

A Model Context Protocol (MCP) egy nyílt szabvány, amely meghatározza, hogy az alkalmazások hogyan biztosítják az eszközöket és a környezetfüggő adatokat a nagy nyelvi modellek (LLM-ek) számára. Lehetővé teszi a külső eszközök egységes, méretezhető integrálását a modell-munkafolyamatokba.

Az alábbi példa bemutatja, hogyan kérdezhet le egy Azure REST API-adattár adatait távoli MCP-kiszolgálóval. A modell valós időben lekéri a repozitórium tartalmát, és annak alapján következtet.

import os
from openai import OpenAI

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

response = client.responses.create(
    model="MODEL_NAME",
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
            "require_approval": "never"
        }
    ],
    input="What transport protocols are supported in the 2025-03-26 version of the MCP spec?"
)

print(response.output_text)

Az MCP eszköz csak a Responses API-ban működik, és minden újabb modellben (gpt-4o, gpt-4.1 és érvelési modelljeink) elérhető. Az MCP-eszköz használatakor csak az eszközdefiníciók importálásakor vagy eszközhívások során használt jogkivonatokért kell fizetnie – további díjak nem merülnek fel.

Jóváhagyások

Alapértelmezés szerint a Responses API-nak explicit jóváhagyásra van szüksége ahhoz, hogy bármilyen adatot megosztanának egy távoli MCP-kiszolgálóval. Ez a jóváhagyási lépés segít biztosítani az átláthatóságot, és szabályozni tudja, hogy a rendszer milyen információkat küld külsőleg.

Javasoljuk, hogy tekintse át a távoli MCP-kiszolgálókkal megosztott összes adatot, és opcionálisan naplózza az auditálási célok érdekében.

Ha jóváhagyásra van szükség, a modell egy elemet ad vissza mcp_approval_request a válasz kimenetében. Ez az objektum tartalmazza a függőben lévő kérelem részleteit, és lehetővé teszi az adatok vizsgálatát vagy módosítását a folytatás előtt.

{
  "id": "mcpr_682bd9cd428c8198b170dc6b549d66fc016e86a03f4cc828",
  "type": "mcp_approval_request",
  "arguments": {},
  "name": "fetch_azure_rest_api_docs",
  "server_label": "github"
}

A távoli MCP-hívás folytatásához válaszolnia kell a jóváhagyási kérelemre egy új válaszobjektum létrehozásával, amely egy mcp_approval_response elemet tartalmaz. Ez az objektum megerősíti azt a szándékot, hogy lehetővé tegye a modell számára a megadott adatok távoli MCP-kiszolgálóra küldését.

import os
from openai import OpenAI

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

response = client.responses.create(
    model="MODEL_NAME",
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
            "require_approval": "never"
        }
    ],
    previous_response_id="<previous_response_id>",
    input=[
        {
            "type": "mcp_approval_response",
            "approve": True,
            "approval_request_id": "<approval_request_id>"
        }
    ]
)

print(response.output_text)

Hitelesítés

Fontos

  • A Responses API-beli MCP-ügyfélhez TLS 1.2-es vagy újabb verzióra van szükség.
  • A kölcsönös TLS (mTLS) jelenleg nem támogatott.
  • Azure szolgáltatáscímkék jelenleg nem támogatottak az MCP-ügyfélforgalom esetében.

A GitHub MCP-kiszolgálótól eltérően a legtöbb távoli MCP-kiszolgálóhoz hitelesítés szükséges. A Válaszok API MCP-eszköze támogatja az egyéni fejléceket, így biztonságosan csatlakozhat ezekhez a kiszolgálókhoz az általuk igényelt hitelesítési sémával.

Közvetlenül a kérésben megadhatja az olyan fejléceket, mint az API-kulcsok, az OAuth hozzáférési jogkivonatok vagy más hitelesítő adatok. A leggyakrabban használt fejléc az Authorization fejléc.

import os
from openai import OpenAI

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

response = client.responses.create(
    model="MODEL_NAME",
    input="What is this repo in 100 words?",
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
            "headers": {"Authorization": "Bearer $YOUR_MCP_TOKEN"}
        }
    ]
)

print(response.output_text)

Háttérfeladatok

A háttér mód lehetővé teszi a hosszú ideig futó feladatok aszinkron futtatását olyan érvelési modellekkel, mint például o3 a .o1-pro Olyan összetett feladatok esetén hasznos, amelyek végrehajtása több percet is igénybe vehet (például Codex- vagy Deep Research-stílusú ügynökök). Amikor egy kérést "background": true használatával elküldenek, a feladatot aszinkron módon dolgozzák fel, és Ön lekérdezi az állapotát.

Háttérfeladat indítása

A feladat várólistára helyezéséhez állítsa be a kérésen a(z) background=true értéket. A szolgáltatás azonnal válaszazonosítóval és queued állapottal tér vissza – ezzel az azonosítóval kérheti le, streamelheti vagy megszakíthatja a feladatot.

import os
from openai import OpenAI

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

response = client.responses.create(
    model="MODEL_NAME",
    input="Write me a very long story.",
    background=True
)

print(response.status)

Szavazás a befejezéshez

Folytassa a lekérdezést, amíg az állapot queued vagy in_progress. Miután a válasz elérte a terminálállapotot, lekérthető.

from time import sleep

while response.status in {"queued", "in_progress"}:
    print(f"Current status: {response.status}")
    sleep(2)
    response = client.responses.retrieve(response.id)

print(f"Final status: {response.status}\nOutput:\n{response.output_text}")

Háttérfeladat megszakítása

Folyamatban lévő háttérfeladat megszakítása a cancel végponttal. A megszakítás művelete idempotens – a további hívások a végső válaszobjektumot adják vissza.

response = client.responses.cancel("<response_id>")
print(response.status)

A háttérválasz streameléséhez állítsa mind a background, mind a stream értékét true értékre. Ez a minta lehetővé teszi a streamelés folytatását, ha a kapcsolat megszakad. Kövesse nyomon a pozícióját minden eseménynél a sequence_number segítségével.

stream = client.responses.create(
    model="MODEL_NAME",
    input="Write me a very long story.",
    background=True,
    stream=True,
)

cursor = None
for event in stream:
    print(event)
    cursor = event["sequence_number"]

A háttérválaszok késése jelenleg nagyobb, mint a szinkron válaszoké. A hiányosságok csökkentése érdekében fejlesztéseket végeznek.

Korlátozások

  • A háttér mód megköveteli store=true. Az állapot nélküli kérelmeket nem támogatják.
  • A streamelést csak akkor folytathatja, ha az eredeti kérést tartalmazza stream=true.
  • Szinkron válasz megszakításához állítsa le közvetlenül a kapcsolatot.

Streamelés folytatása egy adott pontról

Ha megszakad egy folyamkapcsolat, egy ismert eseménytől folytathatja, ha a válaszhoz tartozó stream=true elemben átadja a(z) starting_after=<sequence_number> és a(z) GET értéket. A szolgáltatás a sorszám után kibocsátott eseményeket játssza vissza.

curl -N -X GET "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id>?stream=true&starting_after=42" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY"

Titkosított érvelési elemek

Ha a Responses API-t állapot nélküli módban használja (store=false), akkor is meg kell őriznie a következtetési kontextust a beszélgetés fordulói között. Ehhez titkosított érvelési elemeket is belefoglalhat a kéréseibe.

Ha meg szeretné őrizni az érvelési elemeket a különböző fordulatok között, adja hozzá reasoning.encrypted_content a include paraméterhez. A válasz ezután tartalmazza az érvelési nyomkövetés titkosított verzióját, amelyet átadhat a jövőbeli kéréseknek.

import os
from openai import OpenAI

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

response = client.responses.create(
    model="MODEL_NAME",
    reasoning={"effort": "medium"},
    input="What is the weather like today?",
    tools=[
        # Replace with your function or tool definitions.
    ],
    include=["reasoning.encrypted_content"],
    store=False,
)

print(response.output_text)

A Responses API lehetővé teszi a képek létrehozását beszélgetések és többlépéses munkafolyamatok részeként. Támogatja a környezeten belüli képbemeneteket és -kimeneteket, és beépített eszközöket tartalmaz a képek létrehozásához és szerkesztéséhez.

Az önálló Image API-hoz képest a Responses API két előnyt kínál:

  • Streamelés: Részleges képkimenetek megjelenítése az előállítás során az észlelt késleltetés javítása érdekében.
  • Rugalmas bemenetek: Fogadja el a képfájl azonosítóit bemenetként a nyers kép bájtjai mellett.

Megjegyzés

A Responses API képgeneráló eszközét a gpt-image-1-sorozatú modellek támogatják, és kompatibilis chat- és következtetési modellekből is meghívhatja. A támogatott vezénylési modellek aktuális listáját a cikk későbbi, Támogatott modellek szakaszában találja.

A képgenerálási eszköz jelenleg nem támogatja a streamelési módot. Részleges képek streameléséhez hívja meg a képgenerálási API-t közvetlenül a Responses API-n kívül.

A Responses API használatával beszélgetési rendszerképeket hozhat létre GPT-képmodellekkel.

import base64
import os
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,
    default_headers={
        "x-ms-oai-image-generation-deployment": os.getenv("IMAGE_MODEL_NAME"),
        "api_version": "preview",
    },
)

response = client.responses.create(
    model="MODEL_NAME",
    input="Generate an image of a gray tabby cat hugging an otter with an orange scarf.",
    tools=[{"type": "image_generation"}],
)

image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]

if image_data:
    with open("otter.png", "wb") as f:
        f.write(base64.b64decode(image_data[0]))

Érvelési modellek

Az érvelési modellek válaszok API-val való használatára vonatkozó példákért tekintse meg az érvelési modellek útmutatóját.

Számítógép-használat

A Playwright számítógép-használati funkciója átkerült a dedikált, a számítógép-használati modellről szóló útmutatóba.

Hibaelhárítás

  • 401/403: Ha a Microsoft Entra ID-t használja, ellenőrizze, hogy a jogkivonat hatóköre https://ai.azure.com/.default. HA API-kulcsot használ, győződjön meg arról, hogy a megfelelő kulcsot használja az erőforráshoz.
  • 404: Ellenőrizze, hogy a model megegyezik-e a telepítési névvel.

Kapcsolódó tartalom

  • Last updated on