Abfragelogikmodelle

In diesem Artikel lernen Sie, wie man Abfrageanfragen für Foundation-Modelle schreibt, die für Argumentationsaufgaben optimiert sind und von Unity Gateway bedient werden.

Query the databricks-claude-sonnet-4-5 model using the OpenAI client with extended thinking enabled (budget_tokens set to 10240). Send a reasoning question and print both the thinking summary and the final answer.

Die Databricks Foundation Model API bietet eine einheitliche API zur Interaktion mit allen Basismodellen, einschließlich Reasoning-Modellen. Die Begründung bietet Foundation-Modellen erweiterte Funktionen zur Bewältigung komplexer Aufgaben. Einige Modelle bieten auch Transparenz, indem sie ihren schrittweisen Gedankeprozess vor der Bereitstellung einer endgültigen Antwort offenlegen.

Typen von Begründungsmodellen

Es gibt zwei Arten von Modellen: solche, die ausschließlich auf Logik basieren, und hybride. In der folgenden Tabelle wird beschrieben, wie verschiedene Modelle unterschiedliche Ansätze zur Steuerung der Begründung verwenden:

Abfragebeispiele

Die meisten Argumentationsmodelle verwenden den Endpunkt für Chat-Abschlüsse . Claude Haiku 5.5, Claude Opus 5.5 und Claude Fable 5.1 verwenden die Anthropic Messages API, wie in ihren Beispielen gezeigt.

Claude-Modellbeispiel

import os
from openai import OpenAI

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="system.ai.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)

Beispiel für das Claude Haiku 5.5 Modell

Claude Haiku 5.5 unterstützt adaptives Denken. Setze output_config.effort auf low, medium oder high, um die Denktiefe zu steuern. Databricks verwendet medium , wenn du diesen Parameter weglässt. Um das Schlussfolgern zu deaktivieren, setzen Sie thinking.type auf disabled und lassen Sie output_config weg.

curl -X POST "https://<workspace_host>.databricks.com/serving-endpoints/anthropic/v1/messages" \
  -u token:$DATABRICKS_TOKEN \
  -H "Content-Type: application/json" \
  -H "anthropic-beta: effort-2025-11-24" \
  -d '{
    "model": "databricks-claude-haiku-5-5",
    "max_tokens": 4096,
    "thinking": {
      "type": "adaptive"
    },
    "output_config": {
      "effort": "high"
    },
    "messages": [
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ]
  }'

Beispiel des Modells Claude Opus 5.5

Claude Opus 5.5 verwendet adaptives Denken für jede Anfrage. Setze low auf medium, high, xhigh, max oder output_config.effort, um die Denktiefe zu steuern. Databricks verwendet medium , wenn du diesen Parameter weglässt.

curl -X POST "https://<workspace_host>.databricks.com/ai-gateway/anthropic/v1/messages" \
  -u token:$DATABRICKS_TOKEN \
  -H "Content-Type: application/json" \
  -H "anthropic-beta: effort-2025-11-24" \
  -d '{
    "model": "databricks-claude-opus-5-5",
    "max_tokens": 4096,
    "thinking": {
      "type": "adaptive"
    },
    "output_config": {
      "effort": "high"
    },
    "messages": [
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ]
  }'

Beispiel des Modells Claude Fable 5.1

Claude Fable 5.1 verwendet immer adaptives Denken. Setze low auf medium, high, xhigh, max oder output_config.effort, um die Denktiefe zu steuern.

curl -X POST "https://<workspace_host>.databricks.com/ai-gateway/anthropic/v1/messages" \
  -u token:$DATABRICKS_TOKEN \
  -H "Content-Type: application/json" \
  -H "anthropic-beta: effort-2025-11-24" \
  -d '{
    "model": "databricks-claude-fable-5-1",
    "max_tokens": 4096,
    "thinking": {
      "type": "adaptive"
    },
    "output_config": {
      "effort": "high"
    },
    "messages": [
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ]
  }'

GPT-5.1

Der reasoning_effort Parameter für GPT-5.1 ist standardmäßig auf none festgelegt, kann jedoch in Anforderungen überschrieben werden. Ein höherer kognitiver Aufwand kann zu durchdachteren und präziseren Antworten führen, jedoch die Latenz und Tokennutzung erhöhen.

curl -X POST "https://<workspace_host>/ai-gateway/mlflow/v1/chat/completions" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "system.ai.gpt-5-1",
    "messages": [
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ],
    "max_tokens": 4096,
    "reasoning_effort": "none"
  }'

Beispiel für das GPT OSS-Modell

Der reasoning_effort Parameter akzeptiert "low", "medium" (Standard) oder "high" Werte. Ein höherer kognitiver Aufwand kann zu durchdachteren und präziseren Antworten führen, jedoch die Latenz und Tokennutzung erhöhen.

curl -X POST "https://<workspace_host>/ai-gateway/mlflow/v1/chat/completions" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "system.ai.gpt-oss-120b",
    "messages": [
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ],
    "max_tokens": 4096,
    "reasoning_effort": "high"
  }'

Beispiel für ein Gemini-Modell

In diesem Beispiel wird system.ai.gemini-3-1-proverwendet. Der Parameter reasoning_effort ist standardmäßig auf "low" festgelegt, kann jedoch in Anforderungen, wie im folgenden Beispiel zu sehen ist, überschrieben werden.

curl -X POST "https://<workspace_host>/ai-gateway/mlflow/v1/chat/completions" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "system.ai.gemini-3-1-pro",
    "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"
  }'

Die API-Antwort umfasst sowohl den Denkvorgang als auch Textblöcke.

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
)

Verwalten von Begründungen über mehrere Wendungen hinweg

Dieser Abschnitt ist spezifisch für das databricks-claude-sonnet-4-5 Modell.

Bei Unterhaltungen, die mehrere Runden umfassen, sind nur die Begründungsblöcke, die mit der letzten Assistentenrunde oder dem letzten Werkzeuggebrauch verbunden sind, für das Modell sichtbar und werden als Eingabetoken gezählt.

Wenn Sie keine Reasoning-Token an das Modell zurückgeben möchten (z. B. wenn Sie keine Reasoning-Schritte benötigen), können Sie den Reasoning-Block ganz auslassen. Beispiel:

response = client.chat.completions.create(
    model="system.ai.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)

Wenn Sie das Modell jedoch benötigen, um über den vorherigen Begründungsprozess nachzudenken, z. B. wenn Sie Erfahrungen aufbauen, die die zwischengeschaltete Begründung aufzeigen, müssen Sie die vollständige, unveränderte Assistentennachricht einschließlich des Begründungsblocks aus der vorherigen Runde einschließen. Hier erfahren Sie, wie Sie einen Thread mit der vollständigen Assistentennachricht fortsetzen:

assistant_message = response.choices[0].message

response = client.chat.completions.create(
    model="system.ai.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)

Offene Antwort-API

Wenn Sie die Open Responses-API verwenden, wird die Begründung als reasoning Elemente in der Antwort outputzurückgegeben. Damit das Modell in einer späteren Runde auf Grundlage seiner vorherigen Überlegungen weiterdenken kann, fügen Sie diese reasoning-Elemente – wobei das Feld encrypted_content unverändert bleibt – in das input der nächsten Anfrage ein.

Ein in der Antwortausgabe zurückgegebenes reasoning-Element hat die folgende Form:

{
  "type": "reasoning",
  "id": "rs_abc123",
  "content": [{ "type": "reasoning_text", "text": "Let me work through the question..." }],
  "encrypted_content": "<opaque-provider-signature>"
}

Um die Unterhaltung fortzusetzen, senden Sie die Ausgabe der vorherigen Antwort in input zurück, wobei das Element reasoning wörtlich beibehalten wird:

{
  "model": "databricks-claude-sonnet-4-5",
  "input": [
    { "role": "user", "content": "Why is the sky blue?" },
    {
      "type": "reasoning",
      "id": "rs_abc123",
      "content": [{ "type": "reasoning_text", "text": "Let me work through the question..." }],
      "encrypted_content": "<opaque-provider-signature>"
    },
    { "role": "assistant", "content": "The sky is blue because of Rayleigh scattering..." },
    { "role": "user", "content": "Can you explain it for a five-year-old?" }
  ]
}

Der encrypted_content Wert enthält einen anbieterspezifischen Argumentationsstatus. Wenn es weggelassen oder verändert wird, kann das Modell nicht mehr auf seine früheren Gedankengänge zurückgreifen. Dies gilt für Anthropic Claude- und Google Gemini-Modelle.

Wie funktioniert ein Begründungsmodell?

Mithilfe von Reasoningmodellen werden zusätzlich zu den Standardmäßigen Eingabe- und Ausgabetoken spezielle Begründungstoken eingeführt. Diese Token lassen das Modell durch den Prompt „denken“, sie unterteilen es und lassen es verschiedene Möglichkeiten zur Reaktion in Betracht ziehen. Nach diesem internen Begründungsprozess generiert das Modell seine endgültige Antwort als sichtbare Ausgabetoken. Einige Modelle, z.B. databricks-claude-sonnet-4-5, zeigen diese Begründungstoken Benutzern an, während andere, wie die OpenAI o-Serie, sie verwerfen und nicht in der endgültigen Ausgabe anzeigen.

Weitere Ressourcen

• Abfragen eines Einbettungsmodells.
• Ein Chatmodell abfragen.
• Vision-Modelle abfragen.