Azure modely zdůvodňování OpenAI

Azure modely zdůvodňování OpenAI jsou navržené tak, aby řešily důvody a úlohy řešení problémů se zvýšeným zaměřením a schopností. Tyto modely tráví více času zpracováním a porozuměním požadavku uživatele, což je mimořádně silné v oblastech, jako jsou věda, kódování a matematika v porovnání s předchozími iteracemi.

Klíčové funkce modelů odůvodnění:

  • Komplexní generování kódu: Umožňuje generovat algoritmy a zpracovávat pokročilé úlohy kódování pro podporu vývojářů.
  • Pokročilé řešení problémů: Ideální pro komplexní debaty a řešení vícestranných problémů.
  • Komplexní porovnání dokumentů: Ideální pro analýzu kontraktů, souborů případů nebo právních dokumentů k identifikaci drobných rozdílů.
  • Následování instrukcí a správa pracovních postupů: Zvláště efektivní pro správu pracovních postupů vyžadujících kratší kontext.

Požadavky

  • Nasazený model Azure OpenAI pro odvozování.

  • Pokud používáte příklady REST:

    • Nainstalujte Azure CLI. Další informace najdete v tématu Instalace Azure CLI.

    • Přihlaste se pomocí az login a pak vygenerujte token typu bearer a uložte ho do proměnné prostředí AZURE_OPENAI_AUTH_TOKEN.

      az account get-access-token --resource https://cognitiveservices.azure.com --query accessToken -o tsv

Použití

Tyto modely v současné době nepodporují stejnou sadu parametrů jako jiné modely, které používají rozhraní API pro dokončování chatu.

Rozhraní API pro dokončování chatů

using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001 //currently required for token based authentication

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

ChatClient client = new(
    model: "o4-mini",
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions()
    {

        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
    }
);

ChatCompletionOptions options = new ChatCompletionOptions
{
    MaxOutputTokenCount = 100000
};

ChatMessage[] messages =
[
    new DeveloperChatMessage("You are a helpful assistant"),
    new UserChatMessage("Tell me about the bitter lesson")
];

ChatCompletion completion = client.CompleteChat(messages, options);

Console.WriteLine($"[ASSISTANT]: {completion.Content[0].Text}");

Jak funguje odůvodnění

Modely zdůvodňování generují kromě vstupních a výstupních tokenů tokeny, které už znáte. Tento model tyto tokeny používá k práci s výzvou: přerušení problému, přístupy k vážení a opuštění cest, které se neudržují. Zdůvodnění tokenů se v obsahu zprávy nikdy nezobrazují, ale zabírají místo v kontextovém okně a účtují se jako výstupní tokeny.

Pokud chcete zjistit, kolik zdůvodnění tokenů spotřebuje požadavek, podívejte completion_tokens_details.reasoning_tokens se do odpovědi rozhraní API pro dokončování chatu nebo output_tokens_details.reasoning_tokens v odpovědi rozhraní API pro odpovědi.

gpt-5.4 Modely gpt-5.5 podporují prokládání myšlení pomocí rozhraní API pro odpovědi. Můžou vytvořit viditelný výstup před a mezi obdobími odůvodnění a důvodem mezi voláními nástroje.

V rámci vícenásobné konverzace se vstupní a výstupní tokeny přenesou z každého turnu dál. Co se stane s odůvodněním z předchozích zapnutí, závisí na modelu a na hodnotě reasoning.context , kterou jste nastavili.

Diagram znázorňující, že current_turn poklesnou dřívější důvody, zatímco all_turns nese kompatibilní důvody napříč třemi otočeními.

Pokud chcete zvolit režim, přečtěte si téma Zachování důvodů napříč voláními.

Správa kontextového okna

Zdůvodnění tokenů sdílí kontextové okno se vstupem a viditelným výstupem. Jedna žádost může strávit kdekoli od několika stovek až desítek tisíc důvodových tokenů v závislosti na tom, jak těžké je problém, takže nechte místo pro ně, když žádost zvětšujete.

Objekt využití hlásí přesný počet jednotlivých požadavků:

{
  "usage": {
    "input_tokens": 75,
    "input_tokens_details": {
      "cached_tokens": 0
    },
    "output_tokens": 1186,
    "output_tokens_details": {
      "reasoning_tokens": 1024
    },
    "total_tokens": 1261
  }
}

Velikosti kontextových oken se liší podle modelu. Omezení, která platí pro vaše nasazení, najdete v tématu Podpora rozhraní API a funkcí.

Náklady pod kontrolou

Zdůvodnění tokenů se účtuje jako výstupní tokeny, takže požadavek, který si myslí, že delší náklady jsou větší, i když je viditelná odpověď krátká. Pokud chcete limitovat celkový součet vygenerovaný model, nastavte max_output_tokens ho pomocí rozhraní API pro odpovědi nebo max_completion_tokens pomocí rozhraní API pro dokončování chatu. Obě omezení zahrnují zdůvodnění tokenů, viditelných výstupních tokenů a formátování tokenů.

Omezování výstupních adres řeší pouze polovinu vícenásobné úlohy. Modely zdůvodnění také znovu posílají rostoucí konverzaci při každém zapnutí a all_turns přidávají nad tím dřívější důvody. Pokud chcete snížit, co platíte za tyto opakované vstupní tokeny, přečtěte si téma Ukládání do mezipaměti výzvy.

Přidělení místa pro odůvodnění

Pokud generování dosáhne limitu kontextového okna nebo nastaveného limitu tokenu, vrátí se odpověď neúplně:

{
  "status": "incomplete",
  "incomplete_details": {
    "reason": "max_output_tokens"
  }
}

K této podmínce může dojít dříve, než model vytvoří jakýkoli viditelný výstup. Platíte za vstupní a důvodové tokeny, ale neobdržíte odpověď. Zkontrolujte status každou odpověď, aby vaše aplikace zpracovávala tento případ, a ne jako s prázdným výsledkem.

Abyste se vyhnuli výpadku místa, zarezervujte si alespoň 25 000 tokenů kvůli odůvodnění a výstupu, zatímco se cítíte pro úlohu. Jakmile víte, kolik zdůvodnění tokenů, které vaše výzvy obvykle spotřebovávají, vylaďte vyrovnávací paměť tak, aby odpovídala.

Zachování důvodových položek v kontextu

Když model zdůvodnění volá funkce prostřednictvím rozhraní API pro odpovědi, předejte položky odůvodnění z předchozí odpovědi zpět spolu s výstupem funkce. Pokud model volal několik funkcí na řádku, odešle všechny důvodové položky, položku volání funkce a výstupní položku volání funkce od poslední zprávy uživatele. Model pak pokračuje ve stejném řádku odůvodnění místo toho, abyste začali znovu, což dosáhne dobré odpovědi v menším počtu tokenů.

Nejjednodušším přístupem je předat všechny výstupní položky z předchozí odpovědi do dalšího požadavku, a to buď s previous_response_id , nebo zkopírováním položek do dalšího input pole. Důvody, které nejsou relevantní pro vaše funkce, se ignorují a příslušné položky se zachovají.

Pokud před odesláním oříznete nebo změníte pořadí kontextu, zachovejte vše mezi poslední zprávou uživatele a výstupem volání funkce beze změny.

Úsilí při uvažování

Parametr reasoning_effort říká modelu, kolik si má myslet, než odpoví. Podporované hodnoty se liší podle modelu a zahrnují none, minimal, low, medium, high, , xhigha max. Výchozí hodnoty se také liší podle modelu. Hodnoty, které každý model přijímá, najdete v tématu Podpora rozhraní API a funkcí.

Úsilí Nejlepší pro
none Kritická práce s latencí, která nemá prospěch z důvodů nebo zřetězených volání nástrojů, jako jsou hlas, rychlé načítání informací a klasifikace.
low Efektivní odůvodnění s mírným nárůstem latence. Nástroje pro obleky používají, plánují, hledají a vícestupňová rozhodnutí, kde záleží na rychlosti a nákladech.
medium Vyvážený výchozí bod pro většinu úloh, zejména v případě, že úkol zahrnuje plánování, komplexní odůvodnění nebo úsudek.
high Obtížné odůvodnění, složité ladění, hloubkové plánování a vysoce hodnotné úlohy, kde kvalita záleží více než latence.
xhigh Hloubkové zkoumání, asynchronní pracovní postupy a úlohy agentů s dlouhými běhy Použijte ho, když vaše vyhodnocení ukazuje zisk, který zdůvodňuje dodatečnou latenci a náklady.
max Vaše nejsložitější úkoly. Pokud aktuálně používáte xhigh, porovnejte obě nastavení před přepnutím.

Modely zdůvodnění se přizpůsobují v rámci nastavení, utrácí méně tokenů na jednoduchých úkolech a na složitějších úkolech je těžší přemýšlet. Čím větší je úsilí, tím déle model stráví na požadavku, což obvykle vytváří více zdůvodnění tokenů.

Poznámka

o1-mini nepodporuje reasoning_effort.

V případě rychlejšího viditelného tokenu v aplikacích citlivých na latenci vyžadovat, aby model vytvořil krátký preambuli, než bude důvod hlouběji.

Zprávy pro vývojáře

Zprávy vývojářů ("role": "developer") jsou funkčně stejné jako systémové zprávy.

Přidání zprávy vývojáře do předchozího příkladu kódu by vypadalo takto:


using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001 //currently required for token based authentication

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

ChatClient client = new(
    model: "o4-mini",
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions()
    {

        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
    }
);

ChatCompletionOptions options = new ChatCompletionOptions
{
    ReasoningEffortLevel = ChatReasoningEffortLevel.Low,
    MaxOutputTokenCount = 100000
};

ChatMessage[] messages =
[
    new DeveloperChatMessage("You are a helpful assistant"),
    new UserChatMessage("Tell me about the bitter lesson")
];

ChatCompletion completion = client.CompleteChat(messages, options);

Console.WriteLine($"[ASSISTANT]: {completion.Content[0].Text}");

Volání nástrojů s modely odůvodnění

Rozhraní API pro odpovědi použijte při kombinování důvodů s funkcí nebo vlastními nástroji. Modely gpt-5.6 a novější modely podporují rozhraní API pro dokončování chatu a podporují nástroje, ale rozhraní API pro dokončování chatu tyto dva nástroje nepodporuje. Žádost o dokončení chatu, která zahrnuje tools selhání s následující chybou:

Function tools with reasoning_effort are not supported for gpt-5.6-sol in /v1/chat/completions. To use function tools, use /v1/responses or set reasoning_effort to 'none'.

Požadavek selže i v případě, že neodešlete reasoning_effort, protože tyto modely mají výchozí hodnotu medium. Odeslání tools stačí k aktivaci chyby. Aplikace, která volá nástroje prostřednictvím dokončování chatu, může po upgradu svého nasazení z dřívějšího modelu odůvodnění začít selhává.

Můžete ho vyřešit dvěma způsoby:

  • Doporučeno: Odesílání žádostí o volání nástrojů do rozhraní API odpovědí Tato cesta podporuje celý rozsah reasoning_effort hodnot, vrací důvodové položky, které můžete přenášet přes střídání, a je povrchem, kde se nové funkce odůvodnění dodávají jako první. Návod k migraci najdete v tématu Upgrade aplikace Azure OpenAI z dokončování chatu na rozhraní API pro odpovědi.
  • Pokud musíte zůstat na dokončení chatu, nastavte reasoning_effort na none každý požadavek, který odešle tools. Model pak volá nástroje bez odůvodnění, což ztratí kvalitu plánování, která poskytuje odůvodnění.

Následující žádost ukazuje alternativní řešení dokončení chatu:

curl -X POST "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
      "model": "gpt-5.6-sol",
      "messages": [
          {"role": "user", "content": "What is the weather in Seattle?"}
      ],
      "reasoning_effort": "none",
      "tools": [
        {
          "type": "function",
          "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
              "type": "object",
              "properties": {
                "city": {"type": "string"}
              },
              "required": ["city"]
            }
          }
        }
      ]
  }'

V .NET nastavte stejnou hodnotu prostřednictvímChatCompletionOptions.ReasoningEffortLevel:

using OpenAI.Chat;

ChatTool getWeatherTool = ChatTool.CreateFunctionTool(
    functionName: "get_weather",
    functionDescription: "Get the current weather for a city.",
    functionParameters: BinaryData.FromString("""
        {
          "type": "object",
          "properties": { "city": { "type": "string" } },
          "required": ["city"]
        }
        """));

ChatCompletionOptions options = new ChatCompletionOptions
{
    ReasoningEffortLevel = ChatReasoningEffortLevel.None,
    MaxOutputTokenCount = 100000
};
options.Tools.Add(getWeatherTool);

Úplný typ povrchu naleznete v knihovně OpenAI .NET.

Poznámka

ChatReasoningEffortLevelje v knihovně .NET OpenAI označen jako experimentální, takže generuje OPENAI001 diagnostiku. Potlačit ho tak #pragma warning disable OPENAI001 , jak je znázorněno v předchozích ukázkách, nebo přidat <NoWarn>$(NoWarn);OPENAI001</NoWarn> do souboru projektu. Ověřování na základě tokenů používá stejnou diagnostiku.

Režim odůvodnění

Modely gpt-5.6 podporují dva režimy spuštění v rozhraní API pro odpovědi. Standardní režim je výchozí v Azure OpenAI. Nastavte reasoning.mode na pro obtížné úlohy, které ospravedlňují větší práci modelu a mohou absorbovat dodatečnou latenci.

Režim a úsilí jsou nezávislé ovládací prvky. Režim vybere standardní nebo profesionální spuštění a reasoning_effort řídí, kolik důvodů se model v daném režimu použije.

{
  "model": "gpt-5.6",
  "reasoning": {
    "mode": "pro",
    "effort": "medium"
  },
  "input": "Review this database migration plan and identify potential failure modes."
}

Režim Pro agreguje práci, kterou provádí, do jediné odpovědi a fakturuje tyto tokeny podle standardních sazeb modelu. Vzhledem k tomu, že funguje více práce než standardní režim, můžete očekávat vyšší využití tokenů a vyšší náklady. Stávající nasazení modelů pro udržují aktuální chování a ceny.

Souhrn odůvodnění

Při použití nejnovějších modelů zdůvodňování s rozhraním API pro odpovědi můžete použít parametr souhrnu odůvodnění k získání souhrnů souhrnů řetězce myšlení modelu.

Parametr reasoning.summary není podporován, pokud je povolena orchestrace s více agenty .

Důležité

Pokus o extrahování nezpracovaných důvodů prostřednictvím jiných metod než parametr souhrnu odůvodnění není podporován, může porušit zásady přijatelného použití a může vést k omezování nebo pozastavení při zjištění.

using OpenAI;
using OpenAI.Responses;
using System.ClientModel.Primitives;
using Azure.Identity;

#pragma warning disable OPENAI001 //currently required for token based authentication

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

OpenAIResponseClient client = new(
    model: "o4-mini",
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
    }
);

OpenAIResponse response = await client.CreateResponseAsync(
    userInputText: "What's the optimal strategy to win at poker?",
    new ResponseCreationOptions()
    {
        ReasoningOptions = new ResponseReasoningOptions()
        {
            ReasoningEffortLevel = ResponseReasoningEffortLevel.High,
            ReasoningSummaryVerbosity = ResponseReasoningSummaryVerbosity.Auto,
        },
    });

// Get the reasoning summary from the first OutputItem (ReasoningResponseItem)
Console.WriteLine("=== Reasoning Summary ===");
foreach (var item in response.OutputItems)
{
    if (item is ReasoningResponseItem reasoningItem)
    {
        foreach (var summaryPart in reasoningItem.SummaryParts)
        {
            if (summaryPart is ReasoningSummaryTextPart textPart)
            {
                Console.WriteLine(textPart.Text);
            }
        }
    }
}

Console.WriteLine("\n=== Assistant Response ===");
// Get the assistant's output
Console.WriteLine(response.GetOutputText());

Poznámka

I když je tato možnost povolená, není zaručeno, že se pro každý krok nebo požadavek vygenerují souhrny odůvodnění. Toto chování je očekávané.

Zachování odůvodnění napříč voláními

Stav konverzace a stav odůvodnění nejsou stejné. Předávání zpráv mezi voláními poskytuje modelu historii viditelných konverzací. Trvalé odůvodnění jde ještě o krok dál: u modelů, které ho podporují, může model také vykreslit své vlastní důvodové položky z dřívějších kroků do aktuálního kontextu.

Trvalé odůvodnění se týká kontinuity, ne transparentnosti. Zdůvodnění položek zůstane neprůžné a rozhraní API nikdy nevrátí svůj text zdůvodnění. Nastavte reasoning.context , aby bylo možné určit, na které z dostupných položek odůvodnění může model kreslit.

Value Chování
auto Používá výchozí hodnotu modelu. Vynechání reasoning.context má stejný účinek.
current_turn Zpřístupní aktivní zdůvodnění modelu, ale nevykreslí z dřívějších důvodů další ukázku.
all_turns Vykreslí dostupné a kompatibilní položky z dřívějších důvodů se změní na další ukázku. gpt-5.6 Tuto hodnotu podporují pouze modely.

Modely gpt-5.6 podporují all_turns a používají ho ve výchozím nastavení. Dřívější modely zdůvodnění mají výchozí current_turnhodnotu .

Důležité

Vzhledem k tomu all_turns , že vykresluje další odůvodnění položek v kontextu, zvyšuje tokeny fakturované za požadavek. Pokud upgradujete existující úlohu na model, u konverzací s vícenásobným zapnutím gpt-5.6 můžete očekávat vyšší spotřebu tokenů, i když se váš kód nezmění. Nastavte reasoning.context , aby current_turn se zachovalo dřívější chování.

Mějte na paměti toto chování:

  • Nastavení reasoning.context nevytváří zdůvodnění položek, které ještě nejsou k dispozici. Řídí pouze to, které existující položky model vykresluje.
  • all_turns má účinek pouze v případě, že požadavek může dosáhnout dřívějších položek odpovědi. Použijte previous_response_id, připojte odpověď ke konverzaci nebo přehrajte celou historii odpovědí sami.
  • Při prvním požadavku v konverzaci current_turn se all_turns chovejte stejně, protože ještě neexistuje žádný dřívější důvod.
  • Každá odpověď hlásí režim, který se ve svém reasoning.context poli skutečně používá, jako buď current_turn nebo all_turns. Zkontrolujte toto pole a potvrďte efektivní režim.

Pokračovat v odůvodnění uloženými odpověďmi

Při ukládání odpovědí je nejkratší způsob, previous_response_id jak zpřístupnit dřívější odůvodnění modelu.

Příklad reasoning.context jazyka C# ještě není k dispozici. Vyberte kartu Python nebo REST, abyste viděli, jak nastavit režim a přečíst efektivní hodnotu zpět z odpovědi.

Použije current_turn se při přehrání starších položek odpovědi, které model už nepotřebuje. Tyto položky můžou zůstat v datové části požadavku kvůli kontinuitě, ale služba je nevykreslí do nové ukázky, což snižuje vykreslený kontext v dlouhotrvajících pracovních postupech.

Zachování odůvodnění bez uložených odpovědí

V bezstavovém režimu obsahují položky v poli output odpovědi encrypted_content vlastnost ve výchozím nastavení. Bezstavové režim se použije, když nastavíte storefalsehodnotu , a když vaše organizace používá nulové uchovávání dat. Nemusíte vyžadovat vlastnost: rozhraní API stále přijímá reasoning.encrypted_content parametr include kvůli kompatibilitě, ale už ji nevyžaduje.

Pokud chcete v tomto režimu používat all_turns všechny výstupní položky, připojte další zprávu uživatele a přehrajte celou historii.

Příklad jazyka C# pro bezstavové trvalé odůvodnění ještě není k dispozici. Vyberte kartu Python nebo REST, abyste viděli, jak přehrání zašifrovaných důvodů přechádět položky.

Další informace o šifrovaných důvodech položek najdete v tématu Šifrované položky odůvodnění.

Parametr fáze

V dlouhotrvajících pracovních postupech nebo pracovních postupech náročných na nástroje, které používají gpt-5.5 a gpt-5.4 v rozhraní API pro odpovědi, označte každou zprávu asistenta phase hodnotou. Parametr je nepovinný, ale vynechání může způsobit, že model bude považovat za závěrečnou odpověď a zastaví se včas.

Slouží commentary k aktualizacím zprostředkujícího asistenta, jako je preambule, který model vytváří před voláním nástroje, a final_answer pro dokončenou odpověď. Nepřidávejte phase do uživatelských zpráv.

{
  "model": "gpt-5.5",
  "input": [
    {
      "role": "assistant",
      "phase": "commentary",
      "content": "I'll inspect the logs, then summarize the root cause and the fix."
    },
    {
      "role": "assistant",
      "phase": "final_answer",
      "content": "Root cause: a cache invalidation race."
    },
    {
      "role": "user",
      "content": "Now give me a rollout-safe fix plan."
    }
  ]
}

Když budete pokračovat v konverzaci pomocí previous_response_id, služba za vás zachová předchozí stav asistenta. Pokud si historii asistentů přehrajete sami, ponechte si původní phase hodnotu každé zprávy.

Python skřivan

Modely řady GPT-5 mají schopnost volat nový custom_tool s názvem lark_tool. Tento nástroj je založený na Python lark a dá se použít k flexibilnějšímu omezení výstupu modelu.

Rozhraní API pro odpovědi

{
  "model": "gpt-5-2025-08-07",
  "input": "please calculate the area of a circle with radius equal to the number of 'r's in strawberry",
  "tools": [
    {
      "type": "custom",
      "name": "lark_tool",
      "format": {
        "type": "grammar",
        "syntax": "lark",
        "definition": "start: QUESTION NEWLINE ANSWER\nQUESTION: /[^\\n?]{1,200}\\?/\nNEWLINE: /\\n/\nANSWER: /[^\\n!]{1,200}!/"
      }
    }
  ],
  "tool_choice": "required"
}

Microsoft Entra ID:

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

response = client.responses.create(  
    model="gpt-5",  # replace with your model deployment name  
    tools=[  
        {  
            "type": "custom",
            "name": "lark_tool",
            "format": {
                "type": "grammar",
                "syntax": "lark",
                "definition": "start: QUESTION NEWLINE ANSWER\nQUESTION: /[^\\n?]{1,200}\\?/\nNEWLINE: /\\n/\nANSWER: /[^\\n!]{1,200}!/"
            }
        }  
    ],  
    input=[{"role": "user", "content": "Please calculate the area of a circle with radius equal to the number of 'r's in strawberry"}],  
)  

print(response.model_dump_json(indent=2))

Klíč rozhraní API:

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-5",  # replace with your model deployment name  
    tools=[  
        {  
            "type": "custom",
            "name": "lark_tool",
            "format": {
                "type": "grammar",
                "syntax": "lark",
                "definition": "start: QUESTION NEWLINE ANSWER\nQUESTION: /[^\\n?]{1,200}\\?/\nNEWLINE: /\\n/\nANSWER: /[^\\n!]{1,200}!/"
            }
        }  
    ],  
    input=[{"role": "user", "content": "Please calculate the area of a circle with radius equal to the number of 'r's in strawberry"}],  
)  

print(response.model_dump_json(indent=2))

Výstup:

{
  "id": "resp_689a0cf927408190b8875915747667ad01c936c6ffb9d0d3",
  "created_at": 1754926332.0,
  "error": null,
  "incomplete_details": null,
  "instructions": null,
  "metadata": {},
  "model": "gpt-5",
  "object": "response",
  "output": [
    {
      "id": "rs_689a0cfd1c888190a2a67057f471b5cc01c936c6ffb9d0d3",
      "summary": [],
      "type": "reasoning",
      "encrypted_content": null,
      "status": null
    },
    {
      "id": "msg_689a0d00e60c81908964e5e9b2d6eeb501c936c6ffb9d0d3",
      "content": [
        {
          "annotations": [],
          "text": ""strawberry" has 3 r's, so the radius is 3.\nArea = πr<sup>2</sup> = π × 3<sup>2</sup> = 9π ≈ 28.27 square units.",
          "type": "output_text",
          "logprobs": null
        }
      ],
      "role": "assistant",
      "status": "completed",
      "type": "message"
    }
  ],
  "parallel_tool_calls": true,
  "temperature": 1.0,
  "tool_choice": "auto",
  "tools": [
    {
      "name": "lark_tool",
      "parameters": null,
      "strict": null,
      "type": "custom",
      "description": null,
      "format": {
        "type": "grammar",
        "definition": "start: QUESTION NEWLINE ANSWER\nQUESTION: /[^\\n?]{1,200}\\?/\nNEWLINE: /\\n/\nANSWER: /[^\\n!]{1,200}!/",
        "syntax": "lark"
      }
    }
  ],
  "top_p": 1.0,
  "background": false,
  "max_output_tokens": null,
  "max_tool_calls": null,
  "previous_response_id": null,
  "prompt": null,
  "prompt_cache_key": null,
  "reasoning": {
    "effort": "medium",
    "generate_summary": null,
    "summary": null
  },
  "safety_identifier": null,
  "service_tier": "default",
  "status": "completed",
  "text": {
    "format": {
      "type": "text"
    }
  },
  "top_logprobs": null,
  "truncation": "disabled",
  "usage": {
    "input_tokens": 139,
    "input_tokens_details": {
      "cached_tokens": 0
    },
    "output_tokens": 240,
    "output_tokens_details": {
      "reasoning_tokens": 192
    },
    "total_tokens": 379
  },
  "user": null,
  "content_filters": null,
  "store": true
}

Dokončení chatu

{
  "messages": [
    {
      "role": "user",
      "content": "Which one is larger, 42 or 0?"
    }
  ],
  "tools": [
    {
      "type": "custom",
      "name": "custom_tool",
      "custom": {
        "name": "lark_tool",
        "format": {
          "type": "grammar",
          "grammar": {
            "syntax": "lark",
            "definition": "start: QUESTION NEWLINE ANSWER\nQUESTION: /[^\\n?]{1,200}\\?/\nNEWLINE: /\\n/\nANSWER: /[^\\n!]{1,200}!/"
          }
        }
      }
    }
  ],
  "tool_choice": "required",
  "model": "gpt-5-2025-08-07"
}

Dostupnost

Dostupnost oblastí

Model Oblasti Omezený přístup
gpt-5.6-sol Dostupnost modelu Není potřeba žádná žádost o přístup. V závislosti na úrovni kvóty se vyžaduje žádost o kvótu. Předplatná vrstvy 5 a vrstvy 6 mají ve výchozím nastavení kvótu.
gpt-5.6-terra Dostupnost modelu Není potřeba žádná žádost o přístup. V závislosti na úrovni kvóty se vyžaduje žádost o kvótu. Předplatná vrstvy 5 a vrstvy 6 mají ve výchozím nastavení kvótu.
gpt-5.6-luna Dostupnost modelu Není potřeba žádná žádost o přístup. V závislosti na úrovni kvóty se vyžaduje žádost o kvótu. Předplatná vrstvy 5 a vrstvy 6 mají ve výchozím nastavení kvótu.
gpt-chat-latest Dostupnost modelu Není potřeba žádná žádost o přístup.
gpt-5.5 Dostupnost modelu Není potřeba žádná žádost o přístup. V závislosti na úrovni kvóty se vyžaduje žádost o kvótu. Předplatná vrstvy 5 a vrstvy 6 mají ve výchozím nastavení kvótu.
gpt-5.4-mini Dostupnost modelu Není potřeba žádná žádost o přístup.
gpt-5.4-nano Dostupnost modelu Není potřeba žádná žádost o přístup.
gpt-5.4-pro Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5.4 Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5.3-codex Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5.2-codex Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5.2 Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5.1-codex-max Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5.1 Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5.1-chat Dostupnost modelu Není potřeba žádná žádost o přístup.
gpt-5.1-codex Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5.1-codex-mini Dostupnost modelu Není potřeba žádná žádost o přístup.
gpt-5-pro Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5-codex Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5 Dostupnost modelu Pro tento model už není omezený přístup.
gpt-5-mini Dostupnost modelu Není potřeba žádná žádost o přístup.
gpt-5-nano Dostupnost modelu Není potřeba žádná žádost o přístup.
o3-pro Dostupnost modelu Pro tento model už není omezený přístup.
codex-mini Dostupnost modelu Není potřeba žádná žádost o přístup.
o4-mini Dostupnost modelu Pro tento model už není omezený přístup.
o3 Dostupnost modelu Pro tento model už není omezený přístup.
o3-mini Dostupnost modelu Pro tento model už není omezený přístup.
o1 Dostupnost modelu Pro tento model už není omezený přístup.

Podpora rozhraní API a funkcí

Limity vstupu a výstupu sdílejí dostupný kontextový rozpočet a nepřidávají se. Podrobnosti a příklad výpočtu GPT-5.5 najdete v tématu Vysvětlení limitů tokenů modelu a rozpočtu tokenů rozhraní API odpovědí.

Funkce gpt-5.6-sol, 2026-06-25 gpt-5.6-terra, 2026-06-25 gpt-5.6-luna, 2026-06-25 gpt-5.5, 2026-04-24 gpt-5.4-nano, 2026-03-17 gpt-5.4-mini, 2026-03-17 gpt-5.4-pro gpt-5.4, 2026-03-05 gpt-5.3-codex, 2026-02-24 gpt-5.2-codex, 2026-01-14 gpt-5.2, 2025-12-11 gpt-5.1-codex-max, 2025-12-04 gpt-5.1, 2025-11-13 gpt-5.1-chat, 2025-11-13 gpt-5.1-codex, 2025-11-13 gpt-5.1-codex-mini, 2025-11-13 gpt-5-pro, 2025-10-06 gpt-5-codex, 2025-09-011 gpt-5, 2025-08-07 gpt-5-mini, 2025-08-07 gpt-5-nano, 2025-08-07
Zprávy pro vývojáře ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Strukturované výstupy ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Kontextové okno 1,050,000

Vstupní:
922,000
Výstup:
128,000		 1,050,000

Vstupní:
922,000
Výstup:
128,000		 1,050,000

Vstupní:
922,000
Výstup:
128,000		 1,050,000

Vstupní:
922,000
Výstup:
128,000		 400,000

Vstup: 272 000
Výstup: 128 000
400,000

Vstup: 272 000
Výstup: 128 000
1,050,000

Vstupní:
922,000
Výstup:
128,000		 1,050,000

Vstupní:
922,000
Výstup:
128,000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 128,000

Vstup: 111 616
Výstup: 16 384		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000		 400,000

Vstup: 272 000
Výstup: 128 000
Zdůvodnění7 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ 6 ✅ 4 ✅ ✅ ✅ ✅ 5 ✅ ✅ ✅ ✅
Vstup obrázku ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Rozhraní API pro dokončování chatu ✅ 9 ✅ 9 ✅ 9 ✅ ✅ ✅ - ✅ - - ✅ - ✅ ✅ - - - - ✅ ✅ ✅
Rozhraní API pro odpovědi ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Funkce/nástroje ✅ 9 ✅ 9 ✅ 9 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Paralelní volání nástrojů1 ✅ ✅ ✅ ✅ ✅ ✅ - ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ - ✅ ✅ ✅ ✅
max_completion_tokens 2 ✅ ✅ ✅ ✅ ✅ ✅ - ✅ - - ✅ - ✅ ✅ - - - - ✅ ✅ ✅
Systémové zprávy 3 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Souhrn odůvodnění ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Trvalé odůvodnění8 ✅ ✅ ✅ - - - - - - - - - - - - - - - - - -
Streaming ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ - ✅ ✅ ✅ ✅

1 Paralelní volání nástrojů nejsou podporována, pokud reasoning_effort je nastavena na minimal

2 Modely odůvodnění budou pracovat pouze s parametrem max_completion_tokens při použití rozhraní API pro dokončování chatu. Použijte max_output_tokens s rozhraním API pro odpovědi.

3 Nejnovější modely zdůvodňování podporují systémové zprávy, které usnadňují migraci. Ve stejném požadavku rozhraní API byste neměli používat zprávu vývojáře i systémovou zprávu.

Výchozí hodnota 4gpt-5.1reasoning_effort je none. Když upgradujete z předchozích modelů, mějte na paměti, že možná budete muset aktualizovat kód, aby explicitně zahrnoval úroveň reasoning_effort, pokud chcete, aby se reasoning_effort uskutečnil.

5gpt-5-pro podporuje reasoning_efforthighpouze tuto výchozí hodnotu, i když není explicitně předána do modelu.

6gpt-5.1-codex-max přidává podporu nové reasoning_effort úrovně xhigh, která je nejvyšší úrovní, na kterou je možné nastavit úsilí při odvozování.

7gpt-5.6, gpt-5.5, gpt-5.4, gpt-5.2, gpt-5.1, gpt-5.1-codex, gpt-5.1-codex-max a gpt-5.1-codex-mini podporují 'None' jako hodnotu parametru reasoning_effort. Chcete-li tyto modely použít k vygenerování odpovědí bez odůvodnění, nastavte reasoning_effort='None'. Toto nastavení může zvýšit rychlost.

8 Modely gpt-5.6 podporují all_turnsreasoning.context parametr a používají ho ve výchozím nastavení. Dřívější modely odůvodnění podporují pouze auto a current_turn.

9 Modely gpt-5.6 a novější modely podporují rozhraní API pro dokončování chatu a nástroje funkcí, ale nikoli současně, pokud reasoning_effort není none. Pro volání nástrojů použijte rozhraní API pro odpovědi. Podrobnosti a alternativní řešení najdete v tématu Volání nástrojů s modely odůvodnění.

NOVÉ funkce odůvodnění GPT-5

Funkce Popis
reasoning_effort max je podporováno pouze s gpt-5.6 a rozhraním Responses API
xhigh je podporováno pouze s gpt-5.6, gpt-5.5, gpt-5.4 a gpt-5.1-codex-max
minimal podporuje se pouze u původních modelů zdůvodňování GPT-5. minimal není podporováno s gpt-5.1 nebo vyšší *
S a novějšími gpt-5.6 modely v rozhraní API pro dokončování chatu je jediná hodnota, none kterou můžete kombinovat s nástroji funkcí. Podívejte se na volání nástroje s modely odůvodnění.

Možnosti: none, minimal, low, medium, high, xhighmax
verbosity Nový parametr poskytující podrobnější kontrolu nad tím, jak bude výstižný výstup modelu.

Možnosti:low, medium, high.
reasoning.context Určuje, které dostupné zdůvodnění položek, které model vykresluje, do dalšího kontextu. all_turns se podporuje pouze u gpt-5.6, která ho ve výchozím nastavení používá.

Možnosti:auto, current_turn, all_turns.
reasoning.mode Vybere standardní nebo profesionální spuštění gpt-5.6 pomocí rozhraní API pro odpovědi. Režim Pro před vrácením jedné odpovědi provádí více modelové práce na požadavku, což zvyšuje latenci a využití tokenů. Azure OpenAI se používá standard jako výchozí.

Možnosti:standard, pro.
preamble Modely zdůvodňování řady GPT-5 mají možnost strávit před spuštěním volání funkce nebo nástroje více času "myšlením" .

Když k tomuto plánování dojde, může model poskytnout přehled o plánovacích krocích v odpovědi modelu prostřednictvím nového objektu nazývaného preamble objekt.

Generování preambulí v odpovědi modelu není zaručeno, i když můžete model podpořit použitím parametru instructions a předáním obsahu, jako je například "Před každým voláním funkce je nutné naplánovat důkladně. Před voláním jakékoli funkce vždy vypíšete svůj plán uživateli."
povolené nástroje Můžete zadat více nástrojů pod tool_choice místo jen jednoho.
vlastní typ nástroje Povolí nezpracovaný text (mimo JSON).
lark_tool Umožňuje používat některé možnosti Python lark pro flexibilnější omezení odpovědí modelu.

* gpt-5-codex také nepodporuje reasoning_effortminimal.

Poznámka

  • Pro zabránění vypršení časového limitu se doporučuje o3-pro .
  • o3-pro v současné době nepodporuje generování imagí.

Nepodporováno

V současné době nejsou podporované modely odůvodnění:

  • temperature, top_p, , presence_penaltyfrequency_penalty, , logprobs, top_logprobs, logit_biasmax_tokens

Pokyny pro poskytnutí podnětu

Modely zdůvodnění fungují nejlépe, když jim poskytnete jasný cíl, pevná omezení a explicitní výstupní kontrakt. Na rozdíl od modelů, které nejsou zdůvodnění, nevyžadují, abyste předepisovali všechny přechodné kroky.

  • Uveďte úkol, omezení a formát výstupu, který očekáváte.
  • Chytejte reasoning_effort se jako ladicí knoflík, a ne jako první věc, kterou dosáhnete, když klesne kvalita.
  • U pracovních postupů náročných na agenty nebo výzkumy definujte, co se počítá jako dokončené a jak by měl model ověřit svou vlastní práci.

Výstup Markdownu

Ve výchozím nastavení se modely o3-mini a o1 nepokoušejí o vytvoření výstupu, který zahrnuje formátování Markdown. Běžným případem použití, kdy je toto chování nežádoucí, je, když chcete, aby model výstupoval kód obsažený v bloku kódu markdownu. Když model vygeneruje výstup bez formátování Markdownu, ztratíte funkce, jako je zvýraznění syntaxe, a kopírovatelné bloky kódu v interaktivních prostředích dětského hřiště. Pokud chcete toto nové výchozí chování přepsat a podpořit zahrnutí Markdownu do odpovědí modelu, přidejte řetězec Formatting re-enabled na začátek zprávy vývojáře.

Přidání Formatting re-enabled na začátek zprávy vývojáře nezaručuje, že model do odpovědi zahrne formátování Markdownu, zvyšuje se tím pravděpodobnost pouze. Zjistili jsme z interního testování, že Formatting re-enabled je méně účinný samostatně s modelem o1 než s o3-mini.

Pokud chcete zvýšit výkon Formatting re-enabled , můžete dále rozšířit začátek zprávy vývojáře, což často vede k požadovanému výstupu. Místo pouhého přidání Formatting re-enabled na začátek zprávy pro vývojáře můžete experimentovat s přidáním popisnější počáteční instrukce, jako je jeden z následujících příkladů:

  • Formatting re-enabled - please enclose code blocks with appropriate markdown tags.
  • Formatting re-enabled - code output should be wrapped in markdown.

V závislosti na očekávaném výstupu možná budete muset počáteční zprávu pro vývojáře dále přizpůsobit, aby se zaměřila na váš konkrétní případ použití.

  • Last updated on