ਸਮੱਗਰੀ ਤੇ ਜਾਓ
ਰੀਜ਼ਨਿੰਗ effort

ਰੀਜ਼ਨਿੰਗ effort

ਨਵਾਂ

ਰੀਜ਼ਨਿੰਗ ਕਰਨ ਵਾਲਾ ਮਾਡਲ ਆਪਣਾ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਜਵਾਬ ਦੇ ਨਾਲ, ਇੱਕ ਵੱਖਰੇ ਫੀਲਡ ਵਿੱਚ, ਵਾਪਸ ਕਰਦਾ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ ਇੱਕ ਰਿਕੁਐਸਟ ਫੀਲਡ ਤੈਅ ਕਰਦਾ ਹੈ ਕਿ ਮਾਡਲ ਜਵਾਬ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿੰਨੀ ਡੂੰਘੀ ਰੀਜ਼ਨਿੰਗ ਕਰੇ।

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_content ਵਿੱਚ, ਉੱਤਰ ਨੂੰ content ਵਿੱਚ, ਅਤੇ ਰੀਜ਼ਨਿੰਗ tokens ਨੂੰ 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}
  }
}

ਕਿਹੜੇ ਮਾਡਲ ਰੀਜ਼ਨਿੰਗ ਕਰਦੇ ਹਨ

ਮਾਡਲ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਵਾਪਸ ਕਰਦਾ ਹੈ 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 ਲਈ ਦੱਸਦਾ ਹੈ। ਜਵਾਬ ਵਿੱਚ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਸਿਰਫ਼ ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਮਾਡਲ ਨੇ ਕੁਝ ਪੈਦਾ ਕੀਤਾ ਹੋਵੇ। ਮਾਡਲ ਅਤੇ ਕੀਮਤਾਂ

effort ਸੈੱਟ ਕਰਨਾ

ਹਰ endpoint ਦੀ effort ਲਿਖਣ ਦੀ ਆਪਣੀ ਸ਼ੈਲੀ ਹੈ। ਉਹ ਸਭ ਇੱਕੋ ਚਾਰ ਪੱਧਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਚੁਣਦੇ ਹਨ।

ਫੀਲਡ ਕਿਸਮ ਡਿਫੌਲਟ ਵੇਰਵਾ ਲਾਗੂ ਕਰਨ ਵਾਲੇ
reasoning_effort string high /v1/chat/completions। ਜਵਾਬ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਮਾਡਲ ਕਿੰਨੀ ਡੂੰਘੀ ਰੀਜ਼ਨਿੰਗ ਕਰਦਾ ਹੈ: off, low, medium ਜਾਂ high। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ
reasoning object | string /v1/chat/completions। ਉਹੀ ਮੁੱਲ {"effort": "low"} ਵਜੋਂ ਜਾਂ ਸਿੱਧੀ string ਵਜੋਂ। ਜਦੋਂ ਦੋਵੇਂ ਫੀਲਡ ਭੇਜੇ ਜਾਣ, reasoning_effort ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ
reasoning.effort string high /v1/responses। object {"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 ਕੋਈ ਰੀਜ਼ਨਿੰਗ ਨਹੀਂ। ਜਵਾਬ ਵਿੱਚ ਕੋਈ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਨਹੀਂ ਹੁੰਦਾ।
low ਸੰਖੇਪ ਰੀਜ਼ਨਿੰਗ।
medium default ਦਰਮਿਆਨੀ ਡੂੰਘਾਈ।
high max ਸਭ ਤੋਂ ਡੂੰਘਾ ਪੱਧਰ। ਜੋ ਰਿਕੁਐਸਟ ਕੋਈ ਮੁੱਲ ਨਹੀਂ ਭੇਜਦੀ, ਉਸ ਦਾ ਪੱਧਰ ਇਹੀ ਹੈ।
  • ਮੁੱਲ ਵੱਡੇ ਜਾਂ ਛੋਟੇ ਅੱਖਰਾਂ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਪੜ੍ਹੇ ਜਾਂਦੇ ਹਨ।
  • ਮੁੱਲ default ਦਾ ਮਤਲਬ medium ਹੈ। ਫੀਲਡ ਨੂੰ ਛੱਡ ਦੇਣ ਦਾ ਮਤਲਬ high ਹੈ।
  • Shannon ਮਾਡਲ (shannon-*) ਹਰ ਰਿਕੁਐਸਟ ਵਿੱਚ ਆਪਣੀ ਡੂੰਘਾਈ ਆਪ ਤੈਅ ਕਰਦੇ ਹਨ; GET /v1/models ਉਨ੍ਹਾਂ ਲਈ reasoning_effort: false ਦੱਸਦਾ ਹੈ।

/v1/messages ਉੱਤੇ ਸੋਚਣ ਦਾ ਬਜਟ

/v1/messages ਉੱਤੇ thinking ਫੀਲਡ ਪੱਧਰ ਚੁਣਦਾ ਹੈ। budget_tokens ਉੱਪਰ ਦਿੱਤੇ ਪੱਧਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਚੁਣਦਾ ਹੈ; ਇਹ token ਦੀ ਆਪਣੀ ਕੋਈ ਸੀਮਾ ਨਹੀਂ ਹੈ। adaptive ਨੂੰ enabled ਵਾਂਗ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ।

ਤੁਸੀਂ ਭੇਜਦੇ ਹੋ ਪੱਧਰ
{"type": "disabled"} off
{"type": "enabled", "budget_tokens": n}, ਜਿੱਥੇ n ਵੱਧ ਤੋਂ ਵੱਧ 2,048 ਹੋਵੇ low
n 2,049 ਤੋਂ 8,192 ਤੱਕ medium
ਵੱਡਾ n, ਜਾਂ budget_tokens ਤੋਂ ਬਿਨਾਂ enabled high
ਕੋਈ thinking ਫੀਲਡ ਨਹੀਂ high

ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਕਿੱਥੇ ਪਹੁੰਚਦਾ ਹੈ

ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਹਮੇਸ਼ਾ ਜਵਾਬ ਤੋਂ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ। ਹਰ ਫਾਰਮੈਟ ਵਿੱਚ ਇਸ ਲਈ ਆਪਣੀ ਥਾਂ ਹੈ:

ਐਂਡਪੁਆਇੰਟ stream ਨਹੀਂ ਕੀਤਾ stream ਕੀਤਾ
/v1/chat/completions choices[0].message.reasoning_content: ਇੱਕ string, ਜਾਂ ਜਦੋਂ ਮਾਡਲ ਨੇ ਕੁਝ ਪੈਦਾ ਨਾ ਕੀਤਾ ਹੋਵੇ ਤਾਂ null। delta.content ਵਾਲੇ chunks ਤੋਂ ਪਹਿਲਾਂ choices[0].delta.reasoning_content ਵਾਲੇ chunks।
/v1/responses message ਆਈਟਮ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ output ਆਈਟਮ {"type": "reasoning", "summary": [{"type": "summary_text", "text": "…"}]}। ਰੀਜ਼ਨਿੰਗ ਨਾ ਹੋਣ ਉੱਤੇ ਕੋਈ ਆਈਟਮ ਨਹੀਂ। reasoning ਆਈਟਮ ਵਾਲਾ response.output_item.added, ਫਿਰ response.reasoning_summary_text.delta events ਅਤੇ ਇੱਕ response.reasoning_summary_text.done।
/v1/messages ਪਹਿਲਾ content block {"type": "thinking", "thinking": "…"}, ਫਿਰ text block। ਰੀਜ਼ਨਿੰਗ ਨਾ ਹੋਣ ਉੱਤੇ ਕੋਈ thinking block ਨਹੀਂ। ਇੱਕ thinking content block: content_block_start, thinking_delta ਵਾਲੇ content_block_delta events, content_block_stop। ਟੈਕਸਟ block ਬਾਅਦ ਵਿੱਚ ਆਉਂਦਾ ਹੈ।
{
  "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 ਮਾਡਲ ਹਰ endpoint ਉੱਤੇ, stream ਕੀਤਾ ਜਾਂ ਨਹੀਂ। effort off ਵਾਲੀ ਰਿਕੁਐਸਟ, ਜਾਂ response_format / text.format ਵਾਲੀ ਰਿਕੁਐਸਟ, ਦਾ ਜਵਾਬ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਤੋਂ ਬਿਨਾਂ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।
shannon-3, shannon-3-pro, shannon-3.1, shannon-3.1-pro ਹਰ endpoint ਉੱਤੇ, stream ਕੀਤਾ ਜਾਂ ਨਹੀਂ, ਜਦੋਂ ਵੀ ਮਾਡਲ ਨੇ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਪੈਦਾ ਕੀਤਾ ਹੋਵੇ।
shannon-2-lite, shannon-2-pro /v1/chat/completions, stream ਨਹੀਂ ਕੀਤਾ: message.reasoning_content ਵਿੱਚ। stream ਕੀਤਾ, tools ਜਾਂ response_format ਤੋਂ ਬਿਨਾਂ ਰਿਕੁਐਸਟ ਵਿੱਚ: ਜਦੋਂ ਤੱਕ ਮਾਡਲ ਰੀਜ਼ਨਿੰਗ ਕਰਦਾ ਹੈ stream ਟਿੱਪਣੀ ਲਾਈਨਾਂ : thinking ਲੈ ਕੇ ਆਉਂਦੀ ਹੈ, ਫਿਰ ਜਵਾਬ ਦੇ chunks। /v1/messages, stream ਕੀਤਾ: ਟੈਕਸਟ block ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ thinking block।
shannon-1.6-pro, shannon-coder-1 stream ਕੀਤੇ ਜਵਾਬਾਂ ਵਿੱਚ ਅਤੇ tools ਵਾਲੀਆਂ ਰਿਕੁਐਸਟਾਂ ਦੇ ਜਵਾਬਾਂ ਵਿੱਚ, ਜਦੋਂ ਵੀ ਮਾਡਲ ਨੇ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਪੈਦਾ ਕੀਤਾ ਹੋਵੇ।

/v1/responses ਉੱਤੇ, stream ਨਾ ਕੀਤਾ ਜਵਾਬ Shannon 3 ਪਰਿਵਾਰ ਅਤੇ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਲਈ reasoning ਆਈਟਮ ਲੈ ਕੇ ਆਉਂਦਾ ਹੈ।

stream ਪੜ੍ਹਨਾ

stream ਵਿੱਚ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਪਹਿਲਾਂ, ਆਪਣੇ ਵੱਖਰੇ 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 ਵਿੱਚ, ਰੀਜ਼ਨਿੰਗ ਹੋਵੇ ਜਾਂ ਜਵਾਬ, delta.role: "assistant" ਵੀ ਹੁੰਦਾ ਹੈ। ਸਟ੍ਰੀਮਿੰਗ

ਰੀਜ਼ਨਿੰਗ tokens ਅਤੇ ਬਿਲਿੰਗ

ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ ਰੀਜ਼ਨਿੰਗ tokens ਆਉਟਪੁੱਟ tokens ਹਨ: ਉਨ੍ਹਾਂ ਦਾ ਬਿਲ ਮਾਡਲ ਦੀ ਆਉਟਪੁੱਟ ਕੀਮਤ ਉੱਤੇ ਬਣਦਾ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਗਿਣਤੀ ਵਿੱਚ ਉਹ ਪਹਿਲਾਂ ਹੀ ਸ਼ਾਮਲ ਹਨ। usage ਇੱਥੇ ਰੀਜ਼ਨਿੰਗ ਦਾ ਹਿੱਸਾ ਦਿਖਾਉਂਦੀ ਹੈ:

ਐਂਡਪੁਆਇੰਟ ਫੀਲਡ ਨੋਟ
/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 ਰੀਜ਼ਨਿੰਗ ਅਤੇ ਜਵਾਬ ਇਕੱਠੇ। ਇਸ ਫਾਰਮੈਟ ਵਿੱਚ ਵੱਖਰੀ ਗਿਣਤੀ ਨਹੀਂ ਹੈ।
  • ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ max_tokens ਜਵਾਬ ਦੇ ਟੈਕਸਟ ਨੂੰ ਸੀਮਤ ਕਰਦਾ ਹੈ। ਰੀਜ਼ਨਿੰਗ tokens ਇਸ ਵਿੱਚ ਨਹੀਂ ਗਿਣੇ ਜਾਂਦੇ।
  • ਕਿਉਂਕਿ ਰੀਜ਼ਨਿੰਗ ਦਾ ਬਿਲ ਆਉਟਪੁੱਟ ਵਜੋਂ ਬਣਦਾ ਹੈ, ਇਸ ਲਈ effort ਪੱਧਰ ਇੱਕ ਲਾਗਤ ਸੈਟਿੰਗ ਵੀ ਹੈ: off ਕੋਈ ਰੀਜ਼ਨਿੰਗ tokens ਪੈਦਾ ਨਹੀਂ ਕਰਦਾ।
  • Shannon ਮਾਡਲ prompt_tokens, completion_tokens ਅਤੇ total_tokens (/v1/messages ਉੱਤੇ input_tokens ਅਤੇ output_tokens) ਰੀਜ਼ਨਿੰਗ ਦੇ ਹਿੱਸੇ ਤੋਂ ਬਿਨਾਂ ਦੱਸਦੇ ਹਨ, ਅਤੇ ਪ੍ਰਤੀ token ਇੱਕ ਸਮਤਲ ਕੀਮਤ ਦਾ ਬਿਲ ਬਣਾਉਂਦੇ ਹਨ। ਮਾਡਲ ਅਤੇ ਕੀਮਤਾਂ

ਅਗਲੀ ਰਿਕੁਐਸਟ ਵਿੱਚ ਰੀਜ਼ਨਿੰਗ

ਤੁਹਾਨੂੰ ਰੀਜ਼ਨਿੰਗ ਵਾਪਸ ਭੇਜਣ ਦੀ ਲੋੜ ਨਹੀਂ। ਤੁਹਾਡੀ ਭੇਜੀ ਗੱਲਬਾਤ ਵਿੱਚ thinking block ਜਾਂ reasoning ਆਈਟਮ ਮਾਡਲ ਨੂੰ ਅੱਗੇ ਨਹੀਂ ਦਿੱਤੀ ਜਾਂਦੀ, ਇਸ ਲਈ assistant turn ਇਸ ਦੇ ਨਾਲ ਜਾਂ ਬਿਨਾਂ ਵਾਪਸ ਜਾ ਸਕਦਾ ਹੈ। thinking block ਵਿੱਚ ਦੋ ਫੀਲਡ 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 ਕੋਈ string ਨਹੀਂ ਹੈ।

ਪ੍ਰਮਾਣਿਕਤਾ, ਬੈਲੇਂਸ ਅਤੇ ਸਰਵਰ ਦੀਆਂ ਗਲਤੀਆਂ ਉਹੀ ਹਨ ਜੋ ਹਰ ਰਿਕੁਐਸਟ ਲਈ ਹੁੰਦੀਆਂ ਹਨ। ਗਲਤੀਆਂ