Modele rozumowania zapytań

Z tego artykułu dowiesz się, jak pisać żądania zapytań dla modeli podstawowych zoptymalizowanych pod kątem zadań rozumowania i wysyłać je do punktu końcowego interfejsu API modelu foundation.

Interfejs API modelu Mozaika AI Foundation model udostępnia ujednolicony interfejs API umożliwiający interakcję ze wszystkimi modelami foundation, w tym modelami rozumowania. Rozumowanie daje podstawowe modele ulepszone możliwości do rozwiązywania złożonych zadań. Niektóre modele zapewniają również przejrzystość, ujawniając ich proces myślowy krok po kroku przed dostarczeniem ostatecznej odpowiedzi.

Typy modeli rozumowania

Istnieją dwa typy modeli, tylko rozumowanie i hybryda. W poniższej tabeli opisano sposób używania różnych modeli do kontrolowania rozumowania:

Typ modelu rozumowania	Szczegóły	Przykłady modeli	Parametry
Rozumowanie hybrydowe	Obsługuje zarówno szybkie, błyskawiczne odpowiedzi, jak i głębsze rozumowanie w razie potrzeby.	Modele Claude'a, takie jak databricks-claude-sonnet-4, databricks-claude-sonnet-4-5, databricks-claude-opus-4-5i databricks-claude-opus-4-1.	Uwzględnij następujące parametry, aby użyć rozumowania hybrydowego: thinking budget_tokens: określa liczbę tokenów, których model może używać do myślenia wewnętrznego. Wyższe budżety mogą poprawić jakość złożonych zadań, ale użycie powyżej 32K może się różnić. budget_tokens musi być mniejsza niż max_tokens.
Tylko rozumowanie	Te modele zawsze używają wewnętrznego rozumowania w swoich odpowiedziach.	Modele GPT OSS, takie jak databricks-gpt-oss-120b i databricks-gpt-oss-20b.	Użyj następującego parametru w żądaniu: reasoning_effort: akceptuje wartości "low", "medium" (wartość domyślna) lub "high". Większe nakłady pracy w zakresie rozumowania mogą spowodować bardziej przemyślane i dokładne odpowiedzi, ale mogą zwiększyć opóźnienie i użycie tokenu. Ten parametr jest akceptowany tylko przez ograniczony zestaw modeli, w tym databricks-gpt-oss-120b i databricks-gpt-oss-20b.

Przykłady zapytań

Dostęp do wszystkich modeli rozumowania jest uzyskiwany za pośrednictwem punktu końcowego uzupełniania czatu .

Przykład modelu Claude'a

from openai import OpenAI
import base64
import httpx

client = OpenAI(
  api_key=os.environ.get('YOUR_DATABRICKS_TOKEN'),
  base_url=os.environ.get('YOUR_DATABRICKS_BASE_URL')
  )

response = client.chat.completions.create(
    model="databricks-claude-sonnet-4-5",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
    max_tokens=20480,
    extra_body={
        "thinking": {
            "type": "enabled",
            "budget_tokens": 10240
        }
    }
)

msg = response.choices[0].message
reasoning = msg.content[0]["summary"][0]["text"]
answer = msg.content[1]["text"]

print("Reasoning:", reasoning)
print("Answer:", answer)

GPT-5.1

Parametr reasoning_effort dla GPT-5.1 jest ustawiony domyślnie na wartość none, ale może zostać zmieniony w żądaniach. Większy nakład pracy w zakresie rozumowania może spowodować bardziej przemyślane i dokładne odpowiedzi, ale może zwiększyć opóźnienie i użycie tokenu.

curl -X POST "https://<workspace_host>/serving-endpoints/databricks-gpt-5-1/invocations" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ],
    "max_tokens": 4096,
    "reasoning_effort": "none"
  }'

Przykładowy model GPT OSS

Parametr reasoning_effort akceptuje wartości , "low" (wartość domyślna) "medium""high"lub . Większy nakład pracy w zakresie rozumowania może spowodować bardziej przemyślane i dokładne odpowiedzi, ale może zwiększyć opóźnienie i użycie tokenu.

curl -X POST "https://<workspace_host>/serving-endpoints/databricks-gpt-oss-120b/invocations" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ],
    "max_tokens": 4096,
    "reasoning_effort": "high"
  }'

Przykład modelu Bliźniąt

W tym przykładzie użyto databricks-gemini-3-pro. Parametr reasoning_effort jest domyślnie ustawiony na "low", ale można go nadpisać w żądaniach, jak pokazano w poniższym przykładzie.

curl -X POST "https://<workspace_host>/serving-endpoints/databricks-gemini-3-pro/invocations" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ],
    "max_tokens": 2000,
    "stream": true,
    "reasoning_effort": "high"
  }'

Odpowiedź interfejsu API obejmuje bloki zawartości dotyczące myślenia i tekstu.

ChatCompletionMessage(
    role="assistant",
    content=[
        {
            "type": "reasoning",
            "summary": [
                {
                    "type": "summary_text",
                    "text": ("The question is asking about the scientific explanation for why the sky appears blue... "),
                    "signature": ("EqoBCkgIARABGAIiQAhCWRmlaLuPiHaF357JzGmloqLqkeBm3cHG9NFTxKMyC/9bBdBInUsE3IZk6RxWge...")
                }
            ]
        },
        {
            "type": "text",
            "text": (
                "# Why the Sky Is Blue\n\n"
                "The sky appears blue because of a phenomenon called Rayleigh scattering. Here's how it works..."
            )
        }
    ],
    refusal=None,
    annotations=None,
    audio=None,
    function_call=None,
    tool_calls=None
)

Zarządzanie rozumowaniem podczas wielu tur

Ta sekcja dotyczy databricks-claude-sonnet-4-5 model.

W rozmowach wielokrturnowych tylko bloki rozumowania skojarzone z ostatnią kolejką asystenta lub sesją użycia narzędzia są widoczne dla modelu i liczone jako tokeny wejściowe.

Jeśli nie chcesz przekazywać tokenów rozumowania z powrotem do modelu (na przykład nie potrzebujesz go, aby uzasadnić poprzednie kroki), możesz całkowicie pominąć blok rozumowania. Przykład:

response = client.chat.completions.create(
    model="databricks-claude-sonnet-4-5",
    messages=[
        {"role": "user", "content": "Why is the sky blue?"},
        {"role": "assistant", "content": text_content},
        {"role": "user", "content": "Can you explain in a way that a 5-year-old child can understand?"}
    ],
    max_tokens=20480,
    extra_body={
        "thinking": {
            "type": "enabled",
            "budget_tokens": 10240
        }
    }
)

answer = response.choices[0].message.content[1]["text"]
print("Answer:", answer)

Jeśli jednak potrzebujesz, aby model analizował swój poprzedni proces rozumowania — na przykład jeśli tworzysz doświadczenia, które uwidaczniają jego pośrednie rozumowanie — musisz uwzględnić pełny, niezmodyfikowany komunikat asystenta, w tym blok rozumowania z poprzedniej kolei. Poniżej przedstawiono sposób kontynuowania wątku z pełnym komunikatem asystenta:

assistant_message = response.choices[0].message

response = client.chat.completions.create(
    model="databricks-claude-sonnet-4-5",
    messages=[
        {"role": "user", "content": "Why is the sky blue?"},
        {"role": "assistant", "content": text_content},
        {"role": "user", "content": "Can you explain in a way that a 5-year-old child can understand?"},
        assistant_message,
        {"role": "user", "content": "Can you simplify the previous answer?"}
    ],
    max_tokens=20480,
    extra_body={
        "thinking": {
            "type": "enabled",
            "budget_tokens": 10240
        }
    }
)

answer = response.choices[0].message.content[1]["text"]
print("Answer:", answer)

Jak działa model rozumowania?

Modele rozumowania zawierają specjalne tokeny rozumowania oprócz standardowych tokenów wejściowych i wyjściowych. Te tokeny pozwalają modelowi "myśleć" poprzez podpowiedź, rozbijając ją i rozważając różne sposoby odpowiedzi. Po tym wewnętrznym procesie rozumowania model generuje ostateczną odpowiedź jako widoczne tokeny wyjściowe. Niektóre modele, takie jak databricks-claude-sonnet-4-5, wyświetlają te tokeny rozumowania dla użytkowników, podczas gdy inne, takie jak seria O OpenAI, odrzucają je i nie uwidaczniają ich w końcowych danych wyjściowych.

Dodatkowe zasoby

• Wykonywanie zapytań względem modelu osadzania.
• Zadawanie zapytań do modelu czatu.
• Wykonywanie zapytań względem modeli przetwarzania obrazów.