Modellen voor query-redenering

In dit artikel leer je hoe je queryverzoeken schrijft voor foundation-modellen die geoptimaliseerd zijn voor redeneertaken en worden bediend door Unity Gateway.

Tip

Genie Code kan dit voor je doen. Probeer dit voorbeeldprompt:

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.

Databricks Foundation Model-API biedt een geïntegreerde API voor interactie met alle Foundation-modellen, waaronder redeneringsmodellen. Redenering biedt basismodellen verbeterde mogelijkheden om complexe taken aan te pakken. Sommige modellen bieden ook transparantie door hun stapsgewijze gedachteproces te onthullen voordat ze een definitief antwoord geven.

Typen redeneringsmodellen

Er zijn twee typen modellen, alleen redeneren en hybride. In de volgende tabel wordt beschreven hoe verschillende modellen verschillende benaderingen gebruiken om redenering te beheren:

Type redeneringsmodel Bijzonderheden Voorbeelden van modellen Parameterwaarden
Uitsluitend redeneren Dit model gebruikt redenering bij elk verzoek, en redeneren kan niet worden uitgeschakeld. databricks-gemini-4-argon (ADI-diensten) Gebruik reasoning_effort met de Chat Completions API, of reasoning.effort met de Open Responses API. Geaccepteerde waarden zijn "low", "medium" (standaard), en "high". Met de Google Gemini API gebruik je thinkingLevel in generationConfig.thinkingConfig. Niet-ondersteunde inspanningswaarden worden afgewezen in plaats van opnieuw gemapt. "none" en "minimal" schakel redeneren niet uit en worden afgewezen.
Hybride redeneren Dit model ondersteunt adaptief denken voor dieper redeneren, en denken kan worden uitgeschakeld voor snellere reacties. databricks-claude-haiku-5-5 Gebruik de volgende parameters met de Anthropic Messages API:
  • thinking: Stel type in op adaptive om redeneren te gebruiken of disabled om het uit te schakelen.
  • output_config.effort: Accepteert low, medium, of high. Databricks stelt de standaardwaarde in op medium wanneer je deze parameter weglaat. Andere waarden, waaronder none, xhigh, en max, worden verworpen.
Uitsluitend redeneren Dit model gebruikt adaptief denken voor elk verzoek, en redeneren kan niet worden uitgeschakeld. databricks-claude-opus-5-5 Gebruik de volgende parameters met de Anthropic Messages API:
  • thinking: Stel type in op adaptive. Uitgeschakeld nadenken en handmatig ingestelde budget_tokens-waarden worden afgewezen.
  • output_config.effort: Accepteert xhigh, max, high, medium of low. Databricks stelt de standaardwaarde in op medium wanneer je deze parameter weglaat. Andere waarden, waaronder none en disabled, worden verworpen.
Uitsluitend redeneren Dit model maakt altijd gebruik van adaptief denken, en redeneren kan niet worden uitgeschakeld. databricks-claude-fable-5-1 Gebruik de volgende parameters met de Anthropic Messages API:
  • thinking: Stel type in op adaptive.
  • output_config.effort: Accepteert xhigh, max, high, medium of low. Databricks stelt geen standaard in; Anthropic gebruikt high wanneer je deze parameter weglaat. Andere waarden, waaronder none, worden verworpen.
Hybride redeneren Ondersteunt zowel snelle, directe antwoorden als diepere redenering wanneer dat nodig is.
  • Claude-modellen zoals databricks-claude-sonnet-4-6, databricks-claude-sonnet-4-5, databricks-claude-opus-5, databricks-claude-opus-4-8, databricks-claude-opus-4-7, databricks-claude-opus-4-6, databricks-claude-opus-4-5 en databricks-claude-opus-4-1.
  • databricks-deepseek-v4-1-flash
 Parameters verschillen per model:
  • Voor Claude-modellen gebruik thinking en budget_tokens. De budget_tokens parameter bepaalt hoeveel tokens het model kan gebruiken voor intern denken. Hogere budgetten kunnen de kwaliteit van complexe taken verbeteren, maar het gebruik boven de 32K kan variëren. budget_tokens moet kleiner zijn dan max_tokens.
  • Voor DeepSeek V4.1 Flash reasoning_effort accepteert "low", "high", , "xhigh"of "max" (standaard). "minimal" wordt toegewezen aan "low", en "medium" wordt toegewezen aan "high". "none" of "disabled" schakelt redeneren uit. Andere waarden worden afgewezen.
Uitsluitend redeneren Deze modellen gebruiken altijd interne redenering in hun antwoorden. GPT OSS-modellen zoals databricks-gpt-oss-120b en databricks-gpt-oss-20b. Gebruik de volgende parameter in uw aanvraag:
  • reasoning_effort: accepteert waarden van "low", "medium" (standaard) of "high". Een hogere redenering kan leiden tot meer doordachte en nauwkeurige antwoorden, maar kan de latentie en het tokengebruik verhogen. Deze parameter wordt alleen geaccepteerd door een beperkte set modellen, inclusief databricks-gpt-oss-120b en databricks-gpt-oss-20b.

Queryvoorbeelden

Note

De volgende voorbeelden zijn gebaseerd op Unity Gateway en modelservices. Als u model voor eindpunten gebruikt in plaats van modelservices, vervangt u de naam van de modelservice door een eindpuntnaam. Zie Gedetailleerde lijst van modellen die worden ondersteund door Databricks Foundation Model API's voor een overzicht van beschikbare foundation-modellen en hun modelservice- en eindpuntnamen.

De meeste redeneermodellen gebruiken het chatvoltooiings-endpoint . Claude Haiku 5.5, Claude Opus 5.5 en Claude Fable 5.1 gebruiken de Anthropic Messages API, zoals in hun voorbeelden te zien is.

Voorbeeld van Claude-model

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)

Claude Haiku 5.5 modelvoorbeeld

Claude Haiku 5.5 ondersteunt adaptief denken. Stel output_config.effort in op low, medium of high om de diepte van het redeneren te bepalen. Databricks gebruikt medium wanneer je deze parameter weglaat. Om redeneren uit te schakelen, zet thinking.type op disabled en laat 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?"
      }
    ]
  }'

Voorbeeld van het Claude Opus 5.5 model

Claude Opus 5.5 gebruikt adaptief denken voor elk verzoek. Stel output_config.effort in op low, medium, high, xhigh of max om de redeneerdiepte te regelen. Databricks gebruikt medium wanneer je deze parameter weglaat.

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

voorbeeld van het model Claude Fable 5.1

Claude Fable 5.1 gebruikt altijd adaptief denken. Stel output_config.effort in op low, medium, high, xhigh of max om de redeneerdiepte te regelen.

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

De reasoning_effort parameter voor GPT-5.1 is standaard ingesteld op none, maar kan bij aanvragen worden overschreven. Een hogere redenering kan leiden tot meer doordachte en nauwkeurige antwoorden, maar kan de latentie en het tokengebruik verhogen.

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

Voorbeeld van GPT OSS-model

De reasoning_effort parameter accepteert "low", "medium" (standaard) of "high" waarden. Een hogere redenering kan leiden tot meer doordachte en nauwkeurige antwoorden, maar kan de latentie en het tokengebruik verhogen.

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

Gemini 4 Argon-model voorbeeld

Dit voorbeeld gebruikt system.ai.databricks-gemini-4-argon met reasoning_effort ingesteld op "high". Als je de parameter weglaat, gebruikt het model "medium".

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DATABRICKS_TOKEN"],
    base_url=os.environ["DATABRICKS_BASE_URL"],
)

response = client.chat.completions.create(
    model="system.ai.databricks-gemini-4-argon",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
    max_tokens=2000,
    reasoning_effort="high",
)

print(response.choices[0].message.content)

Voorbeeld van Gemini-model

In dit voorbeeld wordt system.ai.gemini-3-1-progebruikt. De reasoning_effort-parameter is standaard ingesteld op "low", maar kan worden overschreven in verzoeken, zoals te zien in het volgende voorbeeld.

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

Het API-antwoord bevat zowel denk- als tekstinhoudsblokken:

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
)

Redenering gedurende meerdere beurten beheren

Deze sectie is specifiek voor het databricks-claude-sonnet-4-5 model.

In gesprekken met meerdere beurten zijn alleen de redeneringsblokken die zijn gekoppeld aan de laatste beurt van de assistent of de hulpmiddelgebruik sessie zichtbaar voor het model en worden meegeteld als invoertokens.

Als u geen redeneringstokens wilt doorgeven aan het model (bijvoorbeeld omdat u niet wilt dat het redeneert over zijn eerdere stappen), kunt u het redeneringsblok helemaal weglaten. Voorbeeld:

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)

Als u het model echter nodig hebt om na te denken over zijn vorige redeneringsproces - bijvoorbeeld als u ervaringen creëert die de tussenliggende redenering tonen - moet u het volledige, ongewijzigde assistentbericht opnemen, inclusief het redeneringsblok van de vorige beurt. U kunt als volgt een thread voortzetten met het volledige assistentbericht:

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)

Api voor open antwoorden

Wanneer u de API Voor open antwoorden gebruikt, wordt redenering geretourneerd als reasoning items in het antwoord output. Als u het model in een volgende beurt wilt laten voortbouwen op zijn eerdere redenering, neem dan die reasoning-items op in de encrypted_content van de volgende aanvraag, waarbij het veld input ongewijzigd blijft.

Een reasoning item dat wordt geretourneerd in de antwoorduitvoer heeft de volgende vorm:

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

Als u het gesprek wilt voortzetten, stuurt u de uitvoer van de vorige beurt terug in input, waarbij het reasoning-item letterlijk ongewijzigd blijft:

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

De encrypted_content waarde heeft de providerspecifieke redeneringsstatus. Als het wordt weggelaten of gewijzigd, kan het model niet redeneren over zijn eerdere denkproces. Dit geldt voor Anthropic Claude- en Google Gemini-modellen.

Hoe werkt een redeneringsmodel?

Met redeneringsmodellen worden naast de standaardinvoer- en uitvoertokens speciale redeneringstokens geïntroduceerd. Met deze tokens kan het model de prompt doorlopen, opsplitsen en rekening houden met verschillende manieren om te reageren. Na dit interne redeneringsproces genereert het model het uiteindelijke antwoord als zichtbare uitvoertokens. Sommige modellen, zoals databricks-claude-sonnet-4-5, geven deze redeneringstokens weer aan gebruikers, terwijl andere, zoals de OpenAI o-serie, ze negeren en ze niet beschikbaar maken in de uiteindelijke uitvoer.

Aanvullende bronnen

  • Laatst bijgewerkt om