Použijte rozhraní API Azure OpenAI Responses

K generování stavových, víceotáčkových odpovědí použijte rozhraní API Azure OpenAI Responses. Spojuje možnosti z dokončování chatu a rozhraní API asistentů v jednom jednotném prostředí. Rozhraní API pro odpovědi také podporuje computer-use-preview model, který umožňuje využití počítače.

Předpoklady

  • Nasazený model Azure OpenAI
  • Metoda ověřování:
    • Klíč rozhraní API (například AZURE_OPENAI_API_KEY) nebo
    • Microsoft Entra ID (doporučeno).

Instalace nebo upgrade balíčku OpenAI

Nainstalujte nebo upgradujte balíček OpenAI Python.

pip install --upgrade openai

Vygenerování textové odpovědi

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="gpt-4.1-nano", # Replace with your model deployment name 
  input="This is a test.",
)

print(response.model_dump_json(indent=2))

Důležité

Používejte klíče rozhraní API s opatrností. Nezahrnujte klíč API přímo do svého kódu a nikdy ho nezveřejňujte veřejně. Pokud používáte klíč rozhraní API, bezpečně ho uložte do Azure Key Vault. Další informace o bezpečném používání klíčů API v aplikacích najdete v tématu KLÍČEAPI s Azure Key Vault.

Další informace o zabezpečení služeb AI najdete v tématu Ověření požadavků na služby Azure AI.

Načti odpověď

Načtení odpovědi z předchozího volání rozhraní API pro odpovědi

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.retrieve("resp_67cb61fa3a448190bcf2c42d96f0d1a8")

Důležité

Používejte klíče rozhraní API s opatrností. Nezahrnujte klíč API přímo do svého kódu a nikdy ho nezveřejňujte veřejně. Pokud používáte klíč rozhraní API, bezpečně ho uložte do Azure Key Vault. Další informace o bezpečném používání klíčů API v aplikacích najdete v tématu KLÍČEAPI s Azure Key Vault.

Další informace o zabezpečení služeb AI najdete v tématu Ověření požadavků na služby Azure AI.

Odstranit odpověď

Ve výchozím nastavení se data odpovědi uchovávají po dobu 30 dnů. Pokud chcete odstranit uloženou odpověď, zavolejte client.responses.delete("{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")  
)

response = client.responses.delete("resp_67cb61fa3a448190bcf2c42d96f0d1a8")

print(response)

Řetězení odpovědí

Odpovědi můžete zřetězit tak, že předáte response.id z předchozí odpovědi do parametru 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")  
)

response = client.responses.create(
    model="gpt-4o",  # replace with your model deployment name
    input="Define and explain the concept of catastrophic forgetting?"
)

second_response = client.responses.create(
    model="gpt-4o",  # replace with your model deployment name
    previous_response_id=response.id,
    input=[{"role": "user", "content": "Explain this at a level that could be understood by a college freshman"}]
)
print(second_response.model_dump_json(indent=2))

Všimněte si z výstupu, že i když jsme nikdy nesdíleli první vstupní otázku s second_response voláním rozhraní API, předáním previous_response_id model získává úplný kontext předchozí otázky a odpověď na novou otázku.

Výstup:

{
  "id": "resp_67cbc9705fc08190bbe455c5ba3d6daf",
  "created_at": 1741408624.0,
  "error": null,
  "incomplete_details": null,
  "instructions": null,
  "metadata": {},
  "model": "gpt-4o-2024-08-06",
  "object": "response",
  "output": [
    {
      "id": "msg_67cbc970fd0881908353a4298996b3f6",
      "content": [
        {
          "annotations": [],
          "text": "Sure! Imagine you are studying for exams in different subjects like math, history, and biology. You spend a lot of time studying math first and get really good at it. But then, you switch to studying history. If you spend all your time and focus on history, you might forget some of the math concepts you learned earlier because your brain fills up with all the new history facts. \n\nIn the world of artificial intelligence (AI) and machine learning, a similar thing can happen with computers. We use special programs called neural networks to help computers learn things, sort of like how our brain works. But when a neural network learns a new task, it can forget what it learned before. This is what we call \"catastrophic forgetting.\"\n\nSo, if a neural network learned how to recognize cats in pictures, and then you teach it how to recognize dogs, it might get really good at recognizing dogs but suddenly become worse at recognizing cats. This happens because the process of learning new information can overwrite or mess with the old information in its \"memory.\"\n\nScientists and engineers are working on ways to help computers remember everything they learn, even as they keep learning new things, just like students have to remember math, history, and biology all at the same time for their exams. They use different techniques to make sure the neural network doesn’t forget the important stuff it learned before, even when it gets new information.",
          "type": "output_text"
        }
      ],
      "role": "assistant",
      "status": null,
      "type": "message"
    }
  ],
  "parallel_tool_calls": null,
  "temperature": 1.0,
  "tool_choice": null,
  "tools": [],
  "top_p": 1.0,
  "max_output_tokens": null,
  "previous_response_id": "resp_67cbc96babbc8190b0f69aedc655f173",
  "reasoning": null,
  "status": "completed",
  "text": null,
  "truncation": null,
  "usage": {
    "input_tokens": 405,
    "output_tokens": 285,
    "output_tokens_details": {
      "reasoning_tokens": 0
    },
    "total_tokens": 690
  },
  "user": null,
  "reasoning_effort": null
}

Ruční řetězení odpovědí

Alternativně můžete ručně zřetězovat odpovědi pomocí následující metody:

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="gpt-4o",  
    input=inputs
)  
      
print(second_response.model_dump_json(indent=2))

Zkomprimovat odpověď

Komprimace umožňuje zmenšit kontextové okno odeslané do modelu a přitom zachovat základní informace pro pochopení modelu.

Komprimovat pomocí položek, které byly vráceny

Můžete zkomprimovat všechny položky vrácené z předchozích požadavků, jako jsou odůvodnění, zpráva, volání funkce atd.

curl 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": "gpt-4.1",
        "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"
          }
        ]
    }'

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_response = client.responses.compact(
    model="gpt-4.1",
    input=[
    {
        "role": "user",
        "content": "Create a simple landing page for a dog petting cafe.",
    },
    # All items returned from previous requests are included here, like reasoning, message, function call, etc.
    {
        "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",
    },
    ]
)
# Pass the compacted_response.output as input to the next request
print(compacted_response)

Zkomprimovat pomocí předchozího ID odpovědi

Můžete také komprimovat pomocí předchozího ID odpovědi.

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")  
)

# Get back a full response
initial_response = client.responses.create(
        model="gpt-4.1",
        input="What is the size of France?"
    )

print(f"Initial Response: {initial_response.output_text}")

# Now compact the response
compacted_response = client.responses.compact(
    model="gpt-4.1",
    previous_response_id=initial_response.id
)

# use the compacted response in a follow up
followup_response = client.responses.create(
    model="gpt-4.1",
    input=[
        *compacted_response.output,
        {"role": "user", "content": "And what is the capital/major city"}
    ]
)
print(f"Follow-up Response: {followup_response.output_text}")

Komprimace na straně serveru

Kompakci na straně serveru můžete použít také přímo v odpovědích (POST /responses nebo client.responses.create) nastavením context_management s compact_threshold.

  • Když počet výstupních tokenů překročí nakonfigurovanou prahovou hodnotu, rozhraní API odpovědí automaticky spustí komprimace.
  • V tomto režimu nemusíte volat /responses/compact samostatně.
  • Odpověď obsahuje zašifrovanou položku komprimace.
  • Komprimace na straně serveru bude fungovat, když nastavíte store=false u požadavků na vytvoření odpovědí.

Položka komprimace přenese základní předchozí stav a odůvodnění do dalšího převodu pomocí méně tokenů. Je neprůdný a nemá být čitelný pro člověka.

Pokud používáte řetězení bezstavového vstupního pole, připojte výstupní položky jako obvykle. Pokud používáte previous_response_id, předejte při každém zapnutí pouze novou zprávu uživatele. V obou vzorech nese položka komprimace kontext potřebný pro další okno.

Návod

Po připojení výstupních prvků k předchozím vstupním prvkům můžete odstranit prvky, které se vyskytly před posledním kompaktním prvkem, abyste zmenšili velikost požadavků a snížili dlouhou koncovou latenci. Nejnovější položka komprimace má potřebný kontext pro pokračování v konverzaci. Pokud používáte previous_response_id řetězení, neprořezávejte ručně.

Flow

  1. Zavolejte responses jako obvykle. Přidejte context_management spolu s compact_threshold pro povolení komprese na straně serveru.
  2. Pokud výstup překročí prahovou hodnotu, služba aktivuje komprimace, vygeneruje položku komprimace ve výstupním datovém proudu a před pokračováním odvozuje kontext.
  3. Pokračujte v konverzaci jedním z těchto vzorů:
    1. Řetězení bezstavového vstupního pole: připojte výstupní položky, včetně položek komprimace, do dalšího vstupního pole.
    2. previous_response_id řetězení: Při každém kroku předávejte pouze novou uživatelskou zprávu a přenášejte nejnovější ID odpovědi dále.

Příklad

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

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

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

Streamování

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(
    input = "This is a test",
    model = "o4-mini", # replace with model deployment name
    stream = True
)

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

Volání funkcí

Rozhraní API pro odpovědi podporuje volání funkcí.

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="gpt-4o",  # replace with your model deployment name  
    tools=[  
        {  
            "type": "function",  
            "name": "get_weather",  
            "description": "Get the weather for a location",  
            "parameters": {  
                "type": "object",  
                "properties": {  
                    "location": {"type": "string"},  
                },  
                "required": ["location"],  
            },  
        }  
    ],  
    input=[{"role": "user", "content": "What's the weather in San Francisco?"}],  
)  

print(response.model_dump_json(indent=2))  
  
# To provide output to tools, add a response for each tool call to an array passed  
# to the next response as `input`  
input = []  
for output in response.output:  
    if output.type == "function_call":  
        match output.name:  
            case "get_weather":  
                input.append(  
                    {  
                        "type": "function_call_output",  
                        "call_id": output.call_id,  
                        "output": '{"temperature": "70 degrees"}',  
                    }  
                )  
            case _:  
                raise ValueError(f"Unknown function call: {output.name}")  
  
second_response = client.responses.create(  
    model="gpt-4o",  
    previous_response_id=response.id,  
    input=input  
)  

print(second_response.model_dump_json(indent=2))

Interpretátor kódu

Nástroj Interpret kódu umožňuje modelům psát a spouštět kód Pythonu v izolovaném a zabezpečeném prostředí. Podporuje celou řadu pokročilých úloh, mezi které patří:

  • Zpracování souborů s různými formáty dat a strukturami
  • Generování souborů, které obsahují data a vizualizace (například grafy)
  • Iterativní psaní a spouštění kódu pro řešení problémů – modely můžou ladit a opakovat kód, dokud nebude úspěšný.
  • Vylepšení vizuálního odůvodnění v podporovaných modelech (například o3, o4-mini) povolením transformací obrázků, jako je oříznutí, zvětšení a otočení
  • Tento nástroj je užitečný zejména pro scénáře zahrnující analýzu dat, matematické výpočty a generování kódu.
curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses?api-version=preview \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
        "model": "gpt-4.1",
        "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")  
)

instructions = "You are a personal math tutor. When asked a math question, write and run code using the python tool to answer the question."

response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "code_interpreter",
            "container": {"type": "auto"}
        }
    ],
    instructions=instructions,
    input="I need to solve the equation 3x + 11 = 14. Can you help me?",
)

print(response.output)

Containers

Důležité

Interpret kódu má přidatné poplatky nad rámec poplatků založených na tokenech za Azure využití OpenAI. Pokud vaše Responses API volá interpret kódu současně ve dvou různých vláknech, vytvoří se dvě relace interpretu kódu. Každá relace je ve výchozím nastavení aktivní po dobu 1 hodiny s časovým limitem nečinnosti 20 minut.

Nástroj Interpret kódu vyžaduje kontejner – plně izolovaný virtuální počítač, ve kterém může model spouštět kód v jazyce Python. Kontejnery můžou zahrnovat nahrané soubory nebo soubory vygenerované během provádění.

Pokud chcete vytvořit kontejner, zadejte "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } v konfiguraci nástroje při vytváření nového objektu Response. Tím se automaticky vytvoří nový kontejner nebo znovu použije aktivní kontejner z předchozího code_interpreter_call v kontextu modelu. Ve code_interpreter_call ve výstupu API bude obsahovat container_id, který byl vygenerován. Platnost tohoto kontejneru vyprší, pokud se nepoužívá po dobu 20 minut.

Vstupy a výstupy souborů

Při spuštění interpretu kódu může model vytvořit vlastní soubory. Například, pokud požádáte o vytvoření grafu nebo vytvoření souboru CSV, tyto obrazy se vytvoří přímo ve vašem kontejneru. Tyto soubory bude citovat v poznámkách další zprávy.

Všechny soubory ve vstupu modelu se automaticky nahrají do kontejneru. Nemusíte ho explicitně nahrávat do kontejneru.

Podporované soubory

Formát souboru typ MIME
.c text/x-c
.cs text/x-csharp
.cpp text/x-c++
.csv text/csv
.doc application/msword
.docx application/vnd.openxmlformats-officedocument.wordprocessingml.document (formát Microsoft Word)
.html text/html
.java text/x-java
.json application/json
.md text/markdown
.pdf aplikace/pdf
.php text/x-php
.pptx application/vnd.openxmlformats-officedocument.presentationml.presentation
.py text/x-python
.py text/x-script.python
.rb text/x-ruby
.tex text/x-tex
.txt text/obyčejný
.css text/css
.js text/JavaScript
.sh application/x-sh
.ts application/TypeScript
.csv application/csv
.jpeg obrázek (JPEG)
.jpg obrázek (JPEG)
.gif Obrázek/GIF
.pkl application/octet-stream
.png obrázek/png
.tar application/x-tar
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
.xml application/xml nebo "text/xml"
.zip aplikace/zip

Výpis vstupních položek

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.input_items.list("resp_67d856fcfba0819081fd3cffee2aa1c0")

print(response.model_dump_json(indent=2))

Výstup:

{
  "data": [
    {
      "id": "msg_67d856fcfc1c8190ad3102fc01994c5f",
      "content": [
        {
          "text": "This is a test.",
          "type": "input_text"
        }
      ],
      "role": "user",
      "status": "completed",
      "type": "message"
    }
  ],
  "has_more": false,
  "object": "list",
  "first_id": "msg_67d856fcfc1c8190ad3102fc01994c5f",
  "last_id": "msg_67d856fcfc1c8190ad3102fc01994c5f"
}

Vstup obrázku

U modelů s podporou zpracování obrazu jsou podporovány obrázky ve formátu PNG (.png), JPEG (.jpeg a .jpg), WEBP (.webp).

Adresa URL obrázku

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="gpt-4o",
    input=[
        {
            "role": "user",
            "content": [
                { "type": "input_text", "text": "what is in this image?" },
                {
                    "type": "input_image",
                    "image_url": "<image_URL>"
                }
            ]
        }
    ]
)

print(response)

Obrázek s kódováním Base64

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")  
)

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Path to your image
image_path = "path_to_your_image.jpg"

# Getting the Base64 string
base64_image = encode_image(image_path)

response = client.responses.create(
    model="gpt-4o",
    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)

Vstup souboru

Modely s možnostmi zpracování obrazu podporují vstup PDF. Soubory PDF lze poskytnout buď jako data zakódovaná v base64, nebo jako ID souborů. Aby modely interpretovaly obsah PDF, jsou extrahovaný text i obrázek každé stránky zahrnuty do kontextu modelu. To je užitečné, když se klíčové informace předávají prostřednictvím diagramů nebo ne textuálního obsahu.

Poznámka:

  • Veškerý extrahovaný text a obrázky se vloží do kontextu modelu. Ujistěte se, že rozumíte důsledkům používání cen a tokenů při používání souborů PDF jako vstupu.

  • V jedné žádosti API by velikost obsahu nahraného napříč více vstupy (soubory) měla odpovídat kontextové délce modelu.

  • Pouze modely, které podporují vstupy textu i obrázků, mohou přijímat PDF soubory jako vstup.

  • Funkce purpose pro user_data není momentálně podporována. Jako dočasné alternativní řešení budete muset nastavit účel na assistants.

Převod PDF na Base64 a analýza

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: # assumes PDF is in the same directory as the executing script
    data = f.read()

base64_string = base64.b64encode(data).decode("utf-8")

response = client.responses.create(
    model="gpt-4o-mini", # model deployment 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)

Nahrání SOUBORU PDF a analýza

Nahrajte soubor PDF. Funkce purpose pro user_data není momentálně podporována. Jako alternativní řešení budete muset nastavit účel na assistants.

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")  
)

# Upload a file with a purpose of "assistants"
file = client.files.create(
  file=open("nucleus_sampling.pdf", "rb"), # This assumes a .pdf file in the same directory as the executing script
  purpose="assistants"
)

print(file.model_dump_json(indent=2))
file_id = file.id

Výstup:

{
  "id": "assistant-KaVLJQTiWEvdz8yJQHHkqJ",
  "bytes": 4691115,
  "created_at": 1752174469,
  "filename": "nucleus_sampling.pdf",
  "object": "file",
  "purpose": "assistants",
  "status": "processed",
  "expires_at": null,
  "status_details": null
}

Pak vezmete hodnotu id a předáte ho do modelu pro zpracování v části file_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")  
)

response = client.responses.create(
    model="gpt-4o-mini",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_id":"assistant-KaVLJQTiWEvdz8yJQHHkqJ"
                },
                {
                    "type": "input_text",
                    "text": "Summarize this PDF",
                },
            ],
        },
    ]
)

print(response.output_text)

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/files \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -F purpose="assistants" \
  -F file="@your_file.pdf" \

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
        "model": "gpt-4.1",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_file",
                        "file_id": "assistant-123456789"
                    },
                    {
                        "type": "input_text",
                        "text": "ASK SOME QUESTION RELATED TO UPLOADED PDF"
                    }
                ]
            }
        ]
    }'

Použití vzdálených serverů MCP

Možnosti modelu můžete rozšířit připojením k nástrojům hostovaným na vzdálených serverech MCP (Model Context Protocol). Tyto servery udržují vývojáři a organizace a zpřístupňují nástroje, ke kterým mají přístup klienti kompatibilní s MCP, jako je rozhraní API pro odpovědi.

Model Context Protocol (MCP) je otevřený standard, který definuje, jak aplikace poskytují nástroje a kontextová data velkým jazykovým modelům (LLM). Umožňuje konzistentní a škálovatelnou integraci externích nástrojů do pracovních postupů modelu.

Následující příklad ukazuje, jak použít fiktivní server MCP k dotazování na informace o Azure REST API. Díky tomu může model v reálném čase načítat a zdůvodnět obsah úložiště.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
  "model": "gpt-4.1",
  "tools": [
    {
      "type": "mcp",
      "server_label": "github",
      "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
      "require_approval": "never"
    }
  ],
  "input": "What is this repo in 100 words?"
}'

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="gpt-4.1", # replace with your model deployment 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)

Nástroj MCP funguje pouze v rozhraní API pro odpovědi a je k dispozici ve všech novějších modelech (gpt-4o, gpt-4.1 a naše modely odůvodnění). Pokud používáte nástroj MCP, platíte jenom za tokeny použité při importu definic nástrojů nebo volání nástrojů – nejsou zahrnuté žádné další poplatky.

Schválení

Rozhraní API odpovědí ve výchozím nastavení vyžaduje explicitní schválení před sdílením dat se vzdáleným serverem MCP. Tento krok schválení pomáhá zajistit transparentnost a dává vám kontrolu nad tím, jaké informace se odesílají externě.

Doporučujeme zkontrolovat všechna data sdílená se vzdálenými servery MCP a volitelně je protokolovat pro účely auditování.

Pokud je požadováno schválení, model vrátí mcp_approval_request položku ve výstupu odpovědi. Tento objekt obsahuje podrobnosti čekající žádosti a umožňuje zkontrolovat nebo upravit data před pokračováním.

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

Pokud chcete pokračovat ve vzdáleném volání MCP, musíte odpovědět na žádost o schválení vytvořením nového objektu odpovědi, který obsahuje položku mcp_approval_response. Tento objekt potvrzuje váš záměr umožnit modelu odesílat zadaná data na vzdálený server MCP.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
  "model": "gpt-4.1",
  "tools": [
    {
      "type": "mcp",
      "server_label": "github",
      "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
      "require_approval": "never"
    }
  ],
  "previous_response_id": "resp_682f750c5f9c8198aee5b480980b5cf60351aee697a7cd77",
  "input": [{
    "type": "mcp_approval_response",
    "approve": true,
    "approval_request_id": "mcpr_682bd9cd428c8198b170dc6b549d66fc016e86a03f4cc828"
  }]
}'

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="gpt-4.1", # replace with your model deployment name 
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
            "require_approval": "never"
        },
    ],
    previous_response_id="resp_682f750c5f9c8198aee5b480980b5cf60351aee697a7cd77",
    input=[{
        "type": "mcp_approval_response",
        "approve": True,
        "approval_request_id": "mcpr_682bd9cd428c8198b170dc6b549d66fc016e86a03f4cc828"
    }],
)

Autentizace

Důležité

  • Klient MCP v rozhraní API pro odpovědi vyžaduje protokol TLS 1.2 nebo vyšší.
  • vzájemné TLS (mTLS) není v současné době podporováno.
  • Azure značky služeb nejsou v současné době podporovány pro klientský provoz MCP.

Na rozdíl od serveru GitHub MCP vyžaduje většina vzdálených serverů MCP ověřování. Nástroj MCP v rozhraní API pro odpovědi podporuje vlastní hlavičky, které umožňují bezpečné připojení k těmto serverům pomocí schématu ověřování, které vyžadují.

Můžete zadat hlavičky, jako jsou klíče rozhraní API, tokeny OAuth access nebo jiné přihlašovací údaje přímo v požadavku. Nejčastěji používané záhlaví je hlavička Authorization .

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
        "model": "gpt-4.1",
        "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_API_KEY"
                }
            }
        ]
    }'

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="gpt-4.1",
    input="What is this repo in 100 words?",
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://gitmcp.io/Azure/azure-rest-api-specs",
            "headers": {
                "Authorization": "Bearer $YOUR_API_KEY"
            }
        }
    ]
)

print(response.output_text)

Úlohy na pozadí

Režim na pozadí umožňuje spouštět dlouhotrvající úlohy asynchronně pomocí modelů, jako je o3 a o1-pro. To je užitečné zejména u složitých úloh zdůvodnění, které mohou trvat několik minut, například těch, které zpracovávají agenti, jako je Codex nebo Deep Research.

Povolením režimu na pozadí se můžete vyhnout vypršení časových limitů a zachovat spolehlivost během rozšířených operací. Po odeslání "background": true požadavku se úloha zpracuje asynchronně a můžete průběžně dotazovat na její stav.

Pokud chcete spustit úlohu na pozadí, nastavte v požadavku parametr pozadí na true:

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
    "model": "o3",
    "input": "Write me a very long story",
    "background": true
  }'

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 = "o3",
    input = "Write me a very long story",
    background = True
)

print(response.status)

Koncový bod GET použijte ke kontrole stavu odpovědi na pozadí. Pokračujte v dotazování, dokud je stav ve frontě nebo probíhá. Jakmile odpověď dosáhne konečného stavu (terminál), bude k dispozici pro načtení.

curl -X GET https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/resp_1234567890 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

from time import sleep
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 = "o3",
    input = "Write me a very long story",
    background = True
)

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}")

Probíhající úlohu na pozadí můžete zrušit pomocí koncového cancel bodu. Zrušení je idempotentní – následná volání vrátí konečný objekt odpovědi.

curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/resp_1234567890/cancel \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

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.cancel("resp_1234567890")

print(response.status)

Streamování odpovědi na pozadí

Pokud chcete streamovat odpověď na pozadí, nastavte hodnotu background na true i stream na true. To je užitečné, pokud chcete streamování obnovit později v případě vyřazeného připojení. Ke sledování pozice použijte sequence_number z každé události.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
    "model": "o3",
    "input": "Write me a very long story",
    "background": true,
    "stream": true
  }'


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")  
)

# Fire off an async response but also start streaming immediately
stream = client.responses.create(
    model="o3",
    input="Write me a very long story",
    background=True,
    stream=True,
)

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

Poznámka:

Odpovědi na pozadí mají v současné době vyšší latenci při generování prvního tokenu než synchronní odpovědi. Probíhají zlepšení, která mají za cíl snížit tuto mezeru.

Omezení

  • Režim pozadí vyžaduje store=true. Bezstavové požadavky nejsou podporovány.
  • Streamování můžete obnovit pouze v případě, že je součástí stream=truepůvodního požadavku .
  • Pokud chcete zrušit synchronní odpověď, ukončete připojení přímo.

Obnovení streamování z konkrétního bodu

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/resp_1234567890?stream=true&starting_after=42 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

Šifrované položky odůvodnění

Pokud používáte rozhraní API pro odpovědi v bezstavovém režimu nastavením store na hodnotu false, musíte zachovat kontext odůvodnění v rámci konverzací. K dosažení tohoto cíle zahrňte zašifrované logické položky do svých požadavků rozhraní API.

Chcete-li zachovat argumentační položky napříč střídáním, přidejte reasoning.encrypted_content do parametru include ve svém požadavku. Tím se zajistí, že odpověď zahrnuje šifrovanou verzi trasování odůvodnění, kterou je možné předat v budoucích požadavcích.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
    "model": "o4-mini",
    "reasoning": {"effort": "medium"},
    "input": "What is the weather like today?",
    "tools": [<YOUR_FUNCTION GOES HERE>],
    "include": ["reasoning.encrypted_content"]
  }'

Generování obrázků (náhled)

Rozhraní API pro odpovědi umožňuje generování obrázků v rámci konverzací a vícekrokových pracovních postupů. Podporuje vstupy a výstupy obrázků v kontextu a zahrnuje integrované nástroje pro generování a úpravy obrázků.

V porovnání se samostatným rozhraním API pro obrázky nabízí rozhraní API pro odpovědi několik výhod:

  • Streamování: Zobrazení částečných výstupů obrázků během generování za účelem zlepšení vnímané latence
  • Flexibilní vstupy: Přijímejte Image File ID jako vstupy, kromě nezpracovaných bajtů obrázků.

Poznámka:

Nástroj pro generování obrázků v Responses API je podporován pouze modely gpt-image-1-series. Můžete však tento model používat z následujícího seznamu podporovaných modelů: gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o3, gpt-5 a modely řady gpt-5.1.

Nástroj pro generování obrázků rozhraní API pro odpovědi v současné době nepodporuje režim streamování. Pokud chcete použít režim streamování a generovat částečné obrázky, zavolejte rozhraní API pro generování obrázků přímo mimo rozhraní API pro odpovědi.

Použijte rozhraní API pro odpovědi, pokud chcete vytvořit konverzační obrazové zážitky pomocí GPT Image.

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":"gpt-image-1.5", "api_version":"preview"}
)

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

# Save the image to a file
image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]
    
if image_data:
    image_base64 = image_data[0]
    with open("otter.png", "wb") as f:
        f.write(base64.b64decode(image_base64))

Modely odůvodnění

Příklady použití modelů odůvodnění s rozhraním API pro odpovědi najdete v průvodci modely odůvodnění.

Použití počítače

Používání počítače s Playwrightem bylo přesunuto do průvodce modelem využití vyhrazeného počítače.

API rozhraní pro odpovědí

Podpora rozhraní API

Dostupnost v oblastech

Rozhraní API pro odpovědi je aktuálně dostupné v následujících oblastech:

  • Austrálie - východ
  • Jižní Brazílie
  • kanadacentral
  • východní Kanada
  • Eastus
  • eastus2
  • franciecentral
  • Německo – středozápad
  • itálie sever
  • japaneast
  • koreacentral
  • Northcentralus
  • Norsko – východ
  • polskocentral
  • Jižní Afrika – sever
  • southcentralus
  • southeastasia
  • Jižní Indie
  • spaincentral
  • Sweden Central
  • Švýcarsko – sever
  • uaenorth
  • uksouth
  • westus
  • westus3

Podpora modelů

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

V oblastech podporovaných rozhraním API odpovědí není k dispozici každý model. Dostupnost oblasti modelu najdete na stránce models.

Poznámka:

Aktuálně se nepodporuje:

  • Generování obrázků pomocí vícenásobných úprav a streamování
  • Obrázky nelze nahrát jako soubor a pak na tyto obrázky odkazovat jako vstup.

Existuje známý problém s následujícími:

  • Soubor PDF jako vstupní soubor je teď podporovaný, ale nastavení účelu user_data nahrávání souboru není v současné době podporováno.
  • Problémy s výkonem při použití režimu na pozadí se streamováním Očekává se, že se problém brzy vyřeší.

Referenční dokumentace

  • Referenční dokumentace k rozhraní API Responses

Řešení problémů

  • 401/403: Pokud používáte Microsoft Entra ID, ověřte, jestli je váš token vymezen pro https://ai.azure.com/.default. Pokud používáte klíč rozhraní API, ověřte, že pro prostředek používáte správný klíč.
  • 404: Potvrďte, že model odpovídá vašemu názvu nasazení.

Související obsah

  • Last updated on