Použití rozhraní API Azure OpenAI pro odpovědi

Pomocí API pro odpovědi Azure OpenAI generujte stavové, víceotáčkové odpovědi. Spojuje možnosti z dokončování chatu a rozhraní API asistentů v jednom jednotném prostředí. Použijte orchestraci více agentů k delegování nezávislých úloh paralelním podagentům nebo použijte vyhledávání nástrojů k načtení definic nástrojů pouze tehdy, když je model potřebuje. Rozhraní API pro odpovědi také podporuje model computer-use-preview, který využívá využití počítače.

Kompletní popisy parametrů požadavků a odpovědí najdete v referenčních informacích k parametrům rozhraní API odpovědi.

Požadavky

  • Nasazený model Azure OpenAI.
  • Metoda ověřování:
    • Klíč rozhraní API (například AZURE_OPENAI_API_KEY) nebo
    • Microsoft Entra ID (doporučeno).
  • Nainstalujte klientskou knihovnu pro váš jazyk:
    • Python:pip install openai azure-identity
    • .NET: dotnet add package OpenAI a dotnet add package Azure.Identity
    • JavaScript/TypeScript: npm install openai @azure/identity
    • Java: Přidejte do projektu com.openai:openai-java a com.azure:azure-identity.
  • V příkladech REST nastavte AZURE_OPENAI_API_KEY (tok klíče rozhraní API) nebo AZURE_OPENAI_AUTH_TOKEN (tok Microsoft Entra ID).

Podporované oblasti

Před spuštěním ukázek v tomto článku ověřte, že oblast prostředku podporuje Responses API. Pro přístup k nejnovějším funkcím se vyžaduje rozhraní API verze 1. Podrobnosti najdete v životním cyklu verze rozhraní API. Informace o regionální podpoře služby Foundry Agent Service najdete v tabulce dostupnosti v jednotlivých oblastech. Rozhraní API pro odpovědi je aktuálně dostupné v následujících oblastech:

  • australiaeast
  • Brazíliesouth
  • kanadacentral
  • canadaeast
  • centrálus
  • eastus
  • eastus2
  • franciecentral
  • Německo západ střed
  • Severní Itálie
  • japaneast
  • japonský západ
  • koreacentral
  • northcentralus
  • norwayeast
  • polskocentral
  • southafricanorth
  • southcentralus
  • jihovýchodní Asie
  • Jižní Indie
  • španělskocentral
  • swedencentral
  • Severní Švýcarsko
  • switzerlandwest
  • UAE Sever
  • uksouth
  • ukwest
  • westcentralus
  • západní evropa
  • westus
  • westus2
  • westus3

Podporované modely

Rozhraní API pro odpovědi podporuje následující modely:

  • gpt-6-astra (Verze: 2026-09-03)
  • gpt-5.6-sol (Verze: 2026-07-09)
  • gpt-5.6-terra (Verze: 2026-07-09)
  • gpt-5.6-luna (Verze: 2026-07-09)
  • gpt-chat-latest (Verze: 2026-08-06, 2026-06-24, 2026-05-28, 2026-05-05)
  • 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)

Ne každý model je k dispozici v každé podporované oblasti. Zkontrolujte dostupnost oblastí modelů na stránce modelů .

Poznámka

Aktuálně se nepodporuje:

  • Generování obrázků pomocí vícenásobných úprav a streamování

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 Microsoft tento problém vyřeší.

Vygenerování textové odpovědi

Vygenerujte jednoduchou textovou odpověď pomocí rozhraní API pro odpovědi. Nahraďte YOUR-RESOURCE-NAME a MODEL_NAME hodnotami nasazení.

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říklad odpovědi

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

Načíst odpověď

Načte odpověď podle jejího ID z předchozího volání Responses API.

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říklad odpovědi

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

Odstranění odpovědi

Ve výchozím nastavení se data odpovědi uchovávají po dobu 30 dnů. Odstraňte uloženou odpověď podle ID.

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)

Řetězení odpovědí

Řetězec pokračuje předáním ID předchozí odpovědi do 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)

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

Případně můžete ručně přenést výstupní položky v dalším požadavku.

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

Zkomprimovat odpověď

Komprimace snižuje vstupní kontext při zachování základního stavu pro pozdější otočení.

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)

Komprimovat pomocí vrácených položek

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

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

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

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)

Komprimace na straně serveru

Můžete také použít komprimaci na straně serveru přímo v odpovědích (POST /responses nebo client.responses.create) nastavením context_management s parametrem 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 vašich požadavků na vytvoření odpovědi.

Položka komprimaci posune podstatný předchozí stav a logické úvahy do dalšího kola 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.

Tip

Po připojení výstupních položek k předchozím vstupním položkám můžete odstranit položky, které přišly před nejnovější položkou pro komprimaci, aby se zmenšily požadavky a snížila dlouhá latence. Nejnovější položka komprimace má potřebný kontext pro pokračování v konverzaci. Pokud používáte previous_response_id řetězení, neprovázejte ručně.

Flow

  1. Zavolejte responses jako obvykle. Přidejte context_management s compact_threshold pro povolení komprimace 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ředání pouze nové uživatelské zprávy na každém turnu a přeposlání nejnovější ID odpovědi.

Příklad

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(),
    }
  )

streamování

Streamujte odpověď tak, jak je vygenerována nastavením stream=true. Služba generuje přírůstkové události, které můžete využít k vykreslení výstupního tokenu po tokenu.

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

Pokud během streamování dojde k chybě uprostřed datového proudu, systém se pokusí chybu vyřešit interními opakováními. Pokud požadavek stále selže, služba narazí na neopravitelnou chybu. V těchto případech je kód odpovědi HTTP 200 (úspěch), ale chybová událost v datovém proudu obsahuje podrobnosti o chybách, ke kterým dojde v průběhu přenosu.

Server vrátí následující typy chyb:

Typ chyby Lze přeložit jako
server_error Návratový kód 500
too_many_requests Návratový kód 429
forbidden Návratový kód 403
user_error Návratový kód 400

Ukázková chybová událost:

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

Aplikace by měly tyto chyby rozpoznat a řádně zastavit nebo restartovat streamování. Za tokeny vygenerované během neúspěšných odpovědí na streamování se vám neúčtují žádné poplatky.

Strukturované výstupy

Pomocí strukturovaných výstupů vytvořte odpověď podle schématu JSON. V požadavku rozhraní Responses API definujte schéma v text.format. Namísto toho se používá response_format Chat Completions. Příklady pro sady SDK a rozhraní REST, podporovaná omezení schématu a další omezení najdete v článku Strukturované výstupy.

Volání funkcí

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

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)

Správa ochranných omezení a filtrování obsahu

Mantinely (filtry obsahu) se použijí na úrovni nasazení a spouští se automaticky při každém volání rozhraní API odpovědí, takže chrání vstup, který odesíláte, i výstup, který model generuje. Mantinely nakonfigurujete samostatně. Další informace naleznete v tématu Konfigurace mantinely a ovládacích prvků. Tato část ukazuje, jak detekovat a zpracovat výsledky ochranných mechanismů při volání rozhraní Responses API.

Rozhraní Responses API prezentuje výsledky ochranných mechanismů jinak než rozhraní Chat Completions. Místo polí prompt_filter_results a content_filter_results, která vrací chat completions, obsahuje objekt odpovědi pole content_filters na nejvyšší úrovni. Každá položka popisuje jeden výsledek filtru.

Pole Description
blocked Jestli byl obsah zablokovaný.
source_type Určuje, jestli se výsledek vztahuje na prompt (vstup) nebo completion (výstup).
content_filter_results Výsledky kategorií, například hate, , sexualviolencea self_harm s úrovněmi závažnosti, plus volitelné kategorie, jako jailbreak, indirect_attack, protected_material_texta protected_material_code.
content_filter_offsets Znakové posuny, na které se výsledek vztahuje.

Poznámka

Pole content_filters je rozšíření Microsoft Foundry, které není součástí základního schématu odpovědí OpenAI, takže sady SDK pro ni nezpřístupňují typovou vlastnost. Přečtěte si ho jako nezpracované nebo nadbytečné pole, jak je znázorněno v následujících příkladech.

Zjištění blokovaného vstupu

Když mantinely zablokují váš vstup, rozhraní API vrátí chybu HTTP 400 s kódem content_filter. Tuto chybu zachyťte, pokud chcete řádně zpracovat blokované výzvy.

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

Přečíst anotace k ochranným mantinelům

Pokud je požadavek úspěšný, přečtěte z odpovědi pole content_filters a ověřte výsledky ochranných mechanismů pro vstup a výstup.

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

Další informace o kategoriích mantinely a úrovních závažnosti najdete v tématu Přehled mantinely a Práce s poznámkami.

Interpret kódu

Nástroj pro interpretaci kódu umožňuje modelům psát a spouštět kód v jazyce Python v zabezpečeném izolované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 -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

Důležité

Interpret kódu má další poplatky nad rámec poplatků založených na tokenech za využití Azure OpenAI. Pokud vaše rozhraní API pro odpovědi volá interpret kódu současně ve dvou různých vláknech, vytvoří se dvě relace interpretu kódu. Každá relace se účtuje po minutách, přičemž minimální účtovaná doba je pět minut. Relace zůstane aktivní, pokud budete přistupovat ke svému kontejneru během 20minutového časového limitu nečinnosti.

Nástroj Interpret kódu vyžaduje použití kontejneru – plně izolovaného virtuálního počítače, ve kterém může model spouštět Pythonový kód. 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 výstupu rozhraní API bude code_interpreter_call obsahovat container_id, které bylo vygenerováno. Platnost tohoto kontejneru vyprší, pokud se nepoužívá po dobu 20 minut.

Platí následující omezení souborů:

  • Požadavek může obsahovat až 50 ID souborů.
  • Kontejner může obsahovat celkem až 1 000 souborů, včetně vstupních souborů a souborů vygenerovaných interpretem kódu.

Vstupy a výstupy souborů

Při spuštění interpretu kódu může model vytvořit vlastní soubory. Pokud například požádáte o vytvoření grafu nebo vytvoření souboru CSV, vytvoří tyto obrázky 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
.html text/html
.java text/x-java
.json application/json
.md text/markdown
.pdf application/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 prostý text
.css text/css
.js text/JavaScript
.sh application/x-sh
.ts application/TypeScript
.csv application/csv
.jpeg image/jpeg
.jpg image/jpeg
.gif image/gif
.pkl application/octet-stream
.png obrázek/png
.tar application/x-tar
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet (MIME typ pro tabulku Microsoft Excel)
.xml application/xml nebo "text/xml"
.zip aplikace/zip

Výpis vstupních položek

Načíst vstupní položky, které byly odeslány v rámci odpovědi. To je užitečné při kontrole kontextu celé konverzace, včetně všech položek přidaných modelem (například volání funkcí nebo komprimace 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")
)

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

Příklad odpovědi

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

Vstup obrázku

Modely s podporou zpracování obrazu můžou interpretovat obrázky společně s textem. Mohou rozpoznávat objekty, obrazce, barvy a textury a číst text obsažený v obrázku podle omezení uvedených dále v tomto článku.

Obrázek můžete zadat jako vstup požadavku některým z následujících způsobů:

  • Plně kvalifikovaná adresa URL souboru obrázku
  • Identifikátor URI dat s kódováním Base64
  • ID souboru vytvořené pomocí rozhraní Files API

Adresa URL obrázku

Odkaz na obrázek hostovaný na veřejné adrese URL Model načte obrázek a zahrne ho jako součást vstupního obsahu.

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)

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

Odešlete obrázek přímo v textu zakódováním jeho bajtů jako datového URI base64. Tento vzor použijte v případě, že obrázek není dostupný na veřejné adrese URL nebo pokud se chcete vyhnout dalšímu síťovému požadavku.

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)

ID souboru

Nahrajte obrázek pomocí rozhraní Files API a purpose="assistants"pak ve své žádosti odkazujte na vrácené ID souboru. Tento přístup je užitečný, pokud chcete znovu použít stejnou image napříč více požadavky bez opětovného odeslání bajtů.

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="assistants",
        )
        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)

Požadavky na vstup obrázku

Následující tabulka uvádí podporované typy souborů pro vstupy obrázků.

Typ souboru typ MIME
formát PNG image/png
JPEG image/jpeg
WebP image/webp
Neanimovaný GIF image/gif

V jedné žádosti můžete zahrnout až 50 obrázků. Každý jednotlivý soubor obrázku musí být pod 50 MB a kombinovaná velikost všech obrázků v požadavku musí být také pod 50 MB.

Obrázky musí splňovat tyto další požadavky:

  • Obrázek musí být relevantní pro výzvu; model není určený pro nesouvisející vizuální obsah.
  • Obrázky by neměly obsahovat škodlivý ani citlivý obsah, který porušuje zásady obsahu.
  • Soubory obrázků nesmí být poškozené ani nečitelné. Pokud model nemůže zpracovat image, požadavek selže.

Volba úrovně podrobností obrázku

detail Pomocí vlastnosti v input_image části obsahu můžete řídit, jak model zpracovává obrázek. Nižší podrobnosti používají méně tokenů a jsou rychlejší, zatímco vyšší podrobnosti používají více tokenů, ale umožňují zachytit jemné funkce modelu.

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

Následující tabulka popisuje jednotlivé úrovně podrobností.

Úroveň podrobností Description
low Model používá verzi image s nižším rozlišením. Tato možnost používá nejmenší tokeny a vytváří nejrychlejší odpověď, ale model může vynechat jemné podrobnosti.
high Model používá verzi image s vyšším rozlišením. Tato možnost zachycuje jemné podrobnosti, ale používá více tokenů a odpovídá déle.
auto Výchozí nastavení Model vybere odpovídající úroveň podrobností na základě obrázku a výzvy.

Omezení vstupu obrázku

Modely s podporou zpracování obrazu mají následující omezení:

  • Lékařské obrázky: Model není vhodný pro interpretaci specializovaných lékařských obrázků, jako jsou ct scany, a neměl by se používat pro lékařské poradenství.
  • Text v jiných než anglických jazycích: Model nemusí při zpracování obrázků obsahujících text v nelatinkových abecedách, například v japonštině nebo korejštině, dosahovat optimálních výsledků.
  • Malý text: Zvětšení textu v obrázku za účelem zlepšení čitelnosti, ale vyhněte se oříznutí důležitých podrobností.
  • Otočení: Model může nesprávně interpretovat otočený nebo obrácený text a obrázky.
  • Vizuální prvky: Model může mít potíže s grafy nebo textem, kde se liší barvy nebo styly( například plné, přerušované nebo tečkované čáry).
  • Prostorové uvažování: Model má potíže s úlohami, které vyžadují přesnou prostorovou lokalizaci, jako je identifikace šachových pozic.
  • Přesnost: V některých případech může model generovat nesprávné popisy nebo titulky.
  • Tvar obrázku: Model má potíže s panoramatickými snímky a snímky s efektem rybího oka.
  • Metadata a změna velikosti: Model nezpracuje původní názvy souborů ani metadata a obrázky se před analýzou změní, což má vliv na původní rozměry.
  • Počítání: Model může poskytnout přibližný počet objektů na obrázcích.
  • CAPTCHA: Z bezpečnostních důvodů je zaveden systém, který blokuje odesílání CAPTCHA.

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 jednom požadavku rozhraní API můžete zahrnout více než jeden soubor, ale každý soubor musí být nižší než 50 MB. Kombinovaný limit všech souborů v požadavku je 50 MB.
  • Pouze modely, které podporují vstup textu i obrázku, mohou přijímat soubory PDF jako vstup.
  • purpose typu user_data v současné době není podporován. Jako dočasné alternativní řešení budete muset nastavit účel na assistants.

Převod PDF na Base64 a analýza

Odešlete PDF přímo zakódováním jeho bajtů jako data URI v kódování base64. Model obdrží extrahovaný text i vykreslený obrázek každé stránky.

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)

Nahrání SOUBORU PDF a analýza

Nahrajte soubor PDF pomocí purpose="assistants". A purpose of user_data není v současné době podporováno.

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)

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 pomocí vzdáleného serveru MCP dotazovat informace o úložišti Azure REST API. Model načítá a zdůvodní obsah úložiště v reálném čase.

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)

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.

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)

Ověřování

Důležité

  • Klient MCP v rozhraní API pro odpovědi vyžaduje protokol TLS 1.2 nebo vyšší.
  • Vzájemné ověřování pomocí TLS (mTLS) momentálně není podporováno.
  • Značky služeb Azure 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, přístupové tokeny OAuth nebo jiné přihlašovací údaje přímo v požadavku. Nejčastěji používané záhlaví je hlavička Authorization .

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)

Úlohy na pozadí

Režim na pozadí umožňuje asynchronně spouštět dlouhotrvající úlohy s modely pro uvažování, jako jsou o3 a o1-pro. Je užitečné pro složité úlohy, které můžou trvat několik minut (například agenti ve stylu Codex nebo Deep Research). Po odeslání "background": truepožadavku se úloha zpracuje asynchronně a vy se dotazujete na její stav.

Spustit úlohu na pozadí

Nastavte v požadavku background=true, aby se úloha zařadila do fronty. Služba se okamžitě vrátí s ID odpovědi a stavem queued – toto ID použijte k dotazování, streamování nebo zrušení úlohy.

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)

Hlasování o dokončení

Pokračujte v dotazování, dokud je stav queued nebo in_progress. Jakmile odpověď dosáhne stavu terminálu, je k dispozici pro načtení.

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

Zrušení úlohy na pozadí

Zrušte probíhající úlohu na pozadí pomocí koncového bodu cancel. Zrušení je idempotentní – následná volání vrátí finální objekt odpovědi.

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

Chcete-li streamovat odpověď na pozadí, nastavte jak background, tak stream na hodnotu true. Tento model umožňuje obnovit streamování, pokud připojení klesne. Sledujte svou pozici pomocí sequence_number u každé události.

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

Odpovědi na pozadí mají v současné době vyšší latenci času do prvního tokenu než synchronní reakce. Probíhají úpravy k zmenšení této mezery.

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

Pokud se streamované připojení přeruší, můžete navázat od známé události předáním stream=true spolu s starting_after=<sequence_number> v GET do odpovědi. Služba přehraje události emitované po tomto pořadovém čísle.

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"

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

Když používáte Responses API v bezstavovém režimu (store=false), musíte stále zachovat kontext uvažování napříč jednotlivými tahy konverzace. Chcete-li to provést, zahrňte do svých požadavků šifrované položky odůvodnění.

Pokud chcete zachovat odůvodnění položek mezi střídavkami, přidejte reasoning.encrypted_content je do parametru include . Odpověď pak obsahuje zašifrovanou verzi trasování odůvodnění, kterou můžete předat budoucím požadavkům.

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)

Rozhraní API pro odpovědi umožňuje generování obrázků v rámci konverzací a pracovních postupů s více kroky. 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 dvě výhody:

  • Streamování: Zobrazení částečných výstupů obrázků během generování za účelem zlepšení vnímané latence
  • Flexibilní vstupy: Kromě nezpracovaných bajtů obrázků přijměte ID souborů obrázků jako vstupy.

Poznámka

Nástroj pro generování obrázků v Responses API je podporován modely řady gpt-image-1 a můžete ho volat z řady kompatibilních chatovacích a reasoning modelů. Aktuální seznam podporovaných modelů orchestrace najdete v části Podporované modely dále v tomto článku.

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

Pomocí rozhraní API pro odpovědi můžete vytvářet konverzační prostředí obrázků pomocí modelů obrázků GPT.

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

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 nástrojem Playwright bylo přesunuto do samostatné příručky k modelu Computer Use.

Řešení potíží

Proč byla má relace API ukončena z preventivních důvodů?

Pokud používáte modely Astra, abychom zajistili, že agenti správně interpretují a dodržují vaše pokyny, máme systém, který zastaví relace v rozhraní API pro odpovědi, pokud zjistí, že agent nemusí správně interpretovat vaše instrukce v případech, jako je přenos citlivých dat, přístup k citlivým datům nebo provádění destruktivních změn. Pokud byla vaše relace ukončena, nemusí to nutně znamenat, že agent udělal chybu, pouze že stojí za to prověřit jeho kroky a ujistit se, že vaše pokyny správně interpretoval a řídil se jimi.

Které požadavky rozhraní API tento systém monitoruje?

Stejný systém popsaný výše asynchronně monitoruje požadavky na Astra v rozhraní API pro odpovědi. Rozhraní Chat Completions API není tímto konkrétním monitorovacím systémem skenováno. Doporučujeme pro případy použití agentních systémů používat Responses API, protože nabízí co nejlepší výkon a bezpečnost.

Jak zjistit, že tento systém ukončil konverzaci v rozhraní API?

Když bezpečnostní systém zjistí, že agent mohl závažným způsobem nesprávně interpretovat pokyny, rozhraní API vrátí kód bezpečnostní anotace misalignment-enforcement. V takovém případě tuto relaci nelze obnovit.

Co má moje aplikace dělat, pokud se takový případ zjistí?

Můžete zvážit nastavení některého systému, který někomu umožní zkontrolovat akce, které agent v takových konverzacích provedl, například poskytnutím uživatelského rozhraní koncovému uživateli ke kontrole. Jakmile se konverzace zastaví z tohoto důvodu v rozhraní API, nedá se obnovit.

Řešení běžných chyb rozhraní API

Při řešení běžných chyb rozhraní API využijte následující doprovodné materiály:

  • 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