કન્ટેન્ટ પર જાઓ
Reasoning effort

Reasoning effort

નવું

reasoning કરતું મોડેલ તેનો reasoning ટેક્સ્ટ જવાબની બાજુમાં, પોતાના ફીલ્ડમાં પાછો આપે છે. હોસ્ટેડ open-weight મોડેલ્સ પર એક રિક્વેસ્ટ ફીલ્ડ નક્કી કરે છે કે જવાબ આપતા પહેલાં મોડેલ કેટલું ઊંડું reasoning કરે.

POST https://api.shannon-ai.com/v1/chat/completions

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.shannon-ai.com/v1")

response = client.chat.completions.create(
    model="Kimi-K3-3BIT-REAP",
    reasoning_effort="low",
    messages=[{"role": "user", "content": "Is 221 a prime number?"}],
)

message = response.choices[0].message
print("Reasoning:", getattr(message, "reasoning_content", None))
print("Answer:", message.content)
print("Reasoning tokens:", response.usage.completion_tokens_details.reasoning_tokens)

જવાબ reasoning ટેક્સ્ટ reasoning_content માં, જવાબ content માં, અને reasoning ટોકન્સ usage માં લઈ જાય છે:

200 JSON
{
  "id": "chatcmpl-2a6c8e0b4d1f4a3c9e7b5d3f1a8c6e4b",
  "object": "chat.completion",
  "created": 1791590400,
  "model": "Kimi-K3-3BIT-REAP",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "No. 221 = 13 x 17, so it is not prime.",
        "reasoning_content": "Try small primes. 221 / 13 = 17, so 221 = 13 x 17."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 14,
    "completion_tokens": 43,
    "total_tokens": 57,
    "prompt_tokens_details": {"cached_tokens": 0},
    "completion_tokens_details": {"reasoning_tokens": 27}
  }
}

કયા મોડેલ્સ reasoning કરે છે

મોડેલ reasoning ટેક્સ્ટ આપે છે effort ફીલ્ડ લાગુ કરે છે
shannon-1.6-lite — —
shannon-1.6-pro, shannon-2-lite, shannon-2-pro, shannon-3, shannon-3-pro, shannon-3.1, shannon-3.1-pro, shannon-coder-1 હા —
દરેક હોસ્ટેડ open-weight મોડેલ હા હા

આ તે ફ્લેગ્સ capabilities.reasoning અને capabilities.reasoning_effort છે જે GET /v1/models દરેક id માટે જણાવે છે. જવાબ reasoning ટેક્સ્ટ ત્યારે જ લઈ જાય છે જ્યારે મોડેલે કંઈ બનાવ્યું હોય. મોડેલ્સ અને કિંમત

effort સેટ કરવું

દરેક એન્ડપોઇન્ટનું effort લખવાનું પોતાનું રૂપ છે. બધા એ જ ચાર સ્તરોમાંથી એક પસંદ કરે છે.

ફીલ્ડ પ્રકાર ડિફોલ્ટ વર્ણન કોણ લાગુ કરે છે
reasoning_effort string high /v1/chat/completions. જવાબ આપતા પહેલાં મોડેલ કેટલું ઊંડું reasoning કરે: off, low, medium અથવા high. હોસ્ટેડ open-weight મોડેલ્સ
reasoning object | string /v1/chat/completions. એ જ કિંમત {"effort": "low"} તરીકે અથવા સીધી સ્ટ્રિંગ તરીકે. બંને ફીલ્ડ મોકલાય ત્યારે reasoning_effort ગણાય છે. હોસ્ટેડ open-weight મોડેલ્સ
reasoning.effort string high /v1/responses. ઓબ્જેક્ટ {"effort": "low"} તરીકે લખાય છે. હોસ્ટેડ open-weight મોડેલ્સ
thinking object /v1/messages. {"type": "enabled", "budget_tokens": n} અથવા {"type": "disabled"}. બજેટ સ્તરોમાંથી એક પસંદ કરે છે; નીચેનું ટેબલ જુઓ. હોસ્ટેડ open-weight મોડેલ્સ
{
  "model": "Kimi-K3-3BIT-REAP",
  "reasoning_effort": "low",
  "messages": [{"role": "user", "content": "Is 221 a prime number?"}]
}
મૂલ્ય આ પણ સ્વીકારાય છે અસર
off none, minimal કોઈ reasoning નહીં. જવાબ કોઈ reasoning ટેક્સ્ટ લઈ જતો નથી.
low ટૂંકું reasoning.
medium default મધ્યમ ઊંડાઈ.
high max સૌથી ઊંડું સ્તર. કોઈ કિંમત ન મોકલતી રિક્વેસ્ટનું આ સ્તર છે.
  • કિંમતો મોટા કે નાના અક્ષરોની પરવા કર્યા વિના વંચાય છે.
  • કિંમત default નો અર્થ medium છે. ફીલ્ડ છોડવાનો અર્થ high છે.
  • Shannon મોડેલ્સ (shannon-*) દરેક રિક્વેસ્ટમાં પોતાની ઊંડાઈ જાતે નક્કી કરે છે; GET /v1/models તેમના માટે reasoning_effort: false જણાવે છે.

/v1/messages પર થિંકિંગ બજેટ

/v1/messages પર thinking ફીલ્ડ સ્તર પસંદ કરે છે. budget_tokens ઉપરના સ્તરોમાંથી એક પસંદ કરે છે; તે ટોકનની પોતાની મર્યાદા નથી. adaptive ને enabled ની જેમ વાંચવામાં આવે છે.

તમે મોકલો છો સ્તર
{"type": "disabled"} off
n 2,048 સુધી સાથે {"type": "enabled", "budget_tokens": n} low
n 2,049 થી 8,192 medium
મોટું n, અથવા budget_tokens વિના enabled high
thinking ફીલ્ડ નથી high

reasoning ટેક્સ્ટ ક્યાં આવે છે

reasoning ટેક્સ્ટ હંમેશા જવાબથી અલગ હોય છે. દરેક ફોર્મેટમાં તેની પોતાની જગ્યા છે:

એન્ડપોઇન્ટ સ્ટ્રીમ વિના સ્ટ્રીમ સાથે
/v1/chat/completions choices[0].message.reasoning_content: સ્ટ્રિંગ, અથવા મોડેલે કંઈ ન બનાવ્યું હોય ત્યારે null. delta.content વાળા chunks પહેલાં choices[0].delta.reasoning_content વાળા chunks.
/v1/responses message આઇટમ પહેલાં output આઇટમ {"type": "reasoning", "summary": [{"type": "summary_text", "text": "…"}]}. reasoning ન હોય ત્યારે કોઈ આઇટમ નથી. reasoning આઇટમ સાથે response.output_item.added, પછી response.reasoning_summary_text.delta ઇવેન્ટ્સ અને એક response.reasoning_summary_text.done.
/v1/messages પહેલો કન્ટેન્ટ બ્લોક {"type": "thinking", "thinking": "…"}, પછી text બ્લોક. reasoning ન હોય ત્યારે thinking બ્લોક નથી. thinking કન્ટેન્ટ બ્લોક: content_block_start, thinking_delta સાથે content_block_delta ઇવેન્ટ્સ, content_block_stop. ટેક્સ્ટ બ્લોક પછી આવે છે.
{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "No. 221 = 13 x 17, so it is not prime.",
        "reasoning_content": "Try small primes. 221 / 13 = 17, so 221 = 13 x 17."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 14,
    "completion_tokens": 43,
    "total_tokens": 57,
    "prompt_tokens_details": {"cached_tokens": 0},
    "completion_tokens_details": {"reasoning_tokens": 27}
  }
}

ક્યાં જોવું, મોડેલ પ્રમાણે:

મોડેલ્સ ટેક્સ્ટ ક્યાં આવે છે
હોસ્ટેડ open-weight મોડેલ્સ દરેક એન્ડપોઇન્ટ પર, સ્ટ્રીમ સાથે કે વિના. effort off વાળી, અથવા response_format / text.format વાળી રિક્વેસ્ટનો જવાબ reasoning ટેક્સ્ટ વિના અપાય છે.
shannon-3, shannon-3-pro, shannon-3.1, shannon-3.1-pro દરેક એન્ડપોઇન્ટ પર, સ્ટ્રીમ સાથે કે વિના, જ્યારે મોડેલે reasoning ટેક્સ્ટ બનાવ્યો હોય.
shannon-2-lite, shannon-2-pro /v1/chat/completions, સ્ટ્રીમ વિના: message.reasoning_content માં. સ્ટ્રીમ સાથે, tools અથવા response_format વિનાની રિક્વેસ્ટમાં: મોડેલ reasoning કરે ત્યારે સ્ટ્રીમ : thinking કોમેન્ટ લાઇન્સ લઈ જાય છે, પછી જવાબના chunks. /v1/messages, સ્ટ્રીમ સાથે: ટેક્સ્ટ બ્લોક પહેલાં thinking બ્લોક.
shannon-1.6-pro, shannon-coder-1 સ્ટ્રીમ થતા જવાબોમાં અને tools લઈ જતી રિક્વેસ્ટના જવાબોમાં, જ્યારે મોડેલે reasoning ટેક્સ્ટ બનાવ્યો હોય.

/v1/responses પર, સ્ટ્રીમ ન થતો જવાબ Shannon 3 ફેમિલી અને હોસ્ટેડ open-weight મોડેલ્સ માટે reasoning આઇટમ લઈ જાય છે.

સ્ટ્રીમ વાંચવો

સ્ટ્રીમમાં reasoning ટેક્સ્ટ પહેલા આવે છે, પોતાના deltas માં, અને જવાબ પછી આવે છે. બંનેને અલગ છાપો કે સંગ્રહો:

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.shannon-ai.com/v1")

stream = client.chat.completions.create(
    model="Kimi-K3-3BIT-REAP",
    reasoning_effort="medium",
    stream=True,
    messages=[{"role": "user", "content": "Is 221 a prime number?"}],
)

for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        print(reasoning, end="", flush=True)      # the reasoning text comes first
    if delta.content:
        print(delta.content, end="", flush=True)  # then the answer

હોસ્ટેડ open-weight મોડેલનો પહેલો chunk, reasoning હોય કે જવાબ, delta.role: "assistant" પણ લઈ જાય છે. સ્ટ્રીમિંગ

reasoning ટોકન્સ અને બિલિંગ

હોસ્ટેડ open-weight મોડેલ્સ પર, reasoning ટોકન્સ આઉટપુટ ટોકન્સ છે: તેમનું બિલ મોડેલની આઉટપુટ કિંમતે થાય છે, અને આઉટપુટ ગણતરીમાં તે પહેલેથી શામેલ છે. usage અહીં reasoning હિસ્સો બતાવે છે:

એન્ડપોઇન્ટ ફીલ્ડ નોંધ
/v1/chat/completions usage.completion_tokens_details.reasoning_tokens completion_tokens માં પહેલેથી શામેલ.
/v1/responses usage.output_tokens_details.reasoning_tokens output_tokens માં પહેલેથી શામેલ.
/v1/messages usage.output_tokens reasoning અને જવાબ સાથે મળીને. આ ફોર્મેટમાં અલગ ગણતરી નથી.
  • હોસ્ટેડ open-weight મોડેલ્સ પર max_tokens જવાબના ટેક્સ્ટને મર્યાદિત કરે છે. reasoning ટોકન્સ તેમાં ગણાતા નથી.
  • reasoning નું બિલ આઉટપુટ તરીકે થતું હોવાથી, effort સ્તર ખર્ચનું સેટિંગ પણ છે: off કોઈ reasoning ટોકન્સ બનાવતું નથી.
  • Shannon મોડેલ્સ reasoning હિસ્સા વિના prompt_tokens, completion_tokens અને total_tokens (/v1/messages પર input_tokens અને output_tokens) જણાવે છે, અને ટોકન દીઠ એક નિશ્ચિત કિંમતે બિલ કરે છે. મોડેલ્સ અને કિંમત

આગલી રિક્વેસ્ટમાં reasoning

તમારે reasoning પાછું મોકલવાની જરૂર નથી. તમે મોકલેલી વાતચીતમાંનો thinking બ્લોક અથવા reasoning આઇટમ મોડેલને આપવામાં આવતો નથી, તેથી assistant ટર્ન તેની સાથે કે વિના પાછો જઈ શકે. thinking બ્લોકમાં type અને thinking બે ફીલ્ડ હોય છે; તેમાં signature નથી.

એરર્સ

સ્ટેટસ પ્રકાર મેસેજ ક્યારે
400 invalid_request_error unknown reasoning effort '<value>'; expected off, low, medium or high હોસ્ટેડ open-weight મોડેલને યાદી બહારની કિંમત મળી, ઉદાહરણ તરીકે xhigh. તમારા બેલેન્સમાંથી કંઈ કપાતું નથી.
422 invalid_request_error Failed to deserialize the JSON body into the target type: … reasoning_effort સ્ટ્રિંગ નથી.

પ્રમાણીકરણ, બેલેન્સ અને સર્વર એરર્સ દરેક રિક્વેસ્ટ જેવી જ છે. ભૂલ સંભાળ