రీజనింగ్ effort
కొత్తరీజనింగ్ చేసే మోడల్ సమాధానం పక్కన ప్రత్యేక ఫీల్డ్లో తన రీజనింగ్ టెక్స్ట్ను తిరిగి ఇస్తుంది. హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్లో, సమాధానం ఇచ్చే ముందు మోడల్ ఎంత లోతుగా రీజనింగ్ చేయాలో ఒక రిక్వెస్ట్ ఫీల్డ్ సెట్ చేస్తుంది.
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) import OpenAI from "openai";
const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://api.shannon-ai.com/v1" });
const response = await client.chat.completions.create({
model: "Kimi-K3-3BIT-REAP",
reasoning_effort: "low",
messages: [{ role: "user", content: "Is 221 a prime number?" }],
});
const message = response.choices[0].message;
console.log("Reasoning:", message.reasoning_content);
console.log("Answer:", message.content);
console.log("Reasoning tokens:", response.usage.completion_tokens_details.reasoning_tokens); curl https://api.shannon-ai.com/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "Kimi-K3-3BIT-REAP",
"reasoning_effort": "low",
"messages": [
{"role": "user", "content": "Is 221 a prime number?"}
]
}' సమాధానం రీజనింగ్ టెక్స్ట్ను reasoning_content లో, జవాబును content లో, మరియు రీజనింగ్ tokens ను usage లో కలిగి ఉంటుంది:
{
"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 | అవును | — |
| హోస్ట్ చేసిన ప్రతి ఓపెన్-వెయిట్ మోడల్ | అవును | అవును |
ఇవి GET /v1/models ప్రతి id కి నివేదించే capabilities.reasoning మరియు capabilities.reasoning_effort ఫ్లాగ్లు. మోడల్ కొంత ఇచ్చినప్పుడు మాత్రమే సమాధానం రీజనింగ్ టెక్స్ట్ను కలిగి ఉంటుంది. మోడల్స్ & ధరలు
effort ను సెట్ చేయడం
ప్రతి ఎండ్పాయింట్కు effort కోసం తన సొంత రూపం ఉంది. అవన్నీ అవే నాలుగు స్థాయిలలో ఒకదాన్ని ఎంచుకుంటాయి.
| ఫీల్డ్ | రకం | డిఫాల్ట్ | వివరణ | వర్తింపజేసేవి |
|---|---|---|---|---|
reasoning_effort | string | high | /v1/chat/completions. సమాధానం ఇచ్చే ముందు మోడల్ ఎంత లోతుగా రీజనింగ్ చేస్తుంది: off, low, medium లేదా high. | హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్ |
reasoning | object | string | /v1/chat/completions. అదే విలువ {"effort": "low"} గా లేదా సాదా string గా. రెండు ఫీల్డ్లు పంపినప్పుడు reasoning_effort పరిగణించబడుతుంది. | హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్ | |
reasoning.effort | string | high | /v1/responses. {"effort": "low"} ఆబ్జెక్ట్గా రాయబడుతుంది. | హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్ |
thinking | object | /v1/messages. {"type": "enabled", "budget_tokens": n} లేదా {"type": "disabled"}. బడ్జెట్ స్థాయిలలో ఒకదాన్ని ఎంచుకుంటుంది; దిగువన ఉన్న పట్టిక చూడండి. | హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్ |
{
"model": "Kimi-K3-3BIT-REAP",
"reasoning_effort": "low",
"messages": [{"role": "user", "content": "Is 221 a prime number?"}]
} {
"model": "Kimi-K3-3BIT-REAP",
"reasoning": {"effort": "low"},
"input": "Is 221 a prime number?"
} {
"model": "Kimi-K3-3BIT-REAP",
"max_tokens": 1024,
"thinking": {"type": "enabled", "budget_tokens": 2048},
"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 పైన ఉన్న స్థాయిలలో ఒకదాన్ని ఎంచుకుంటుంది; అది సొంత 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 |
రీజనింగ్ టెక్స్ట్ ఎక్కడ వస్తుంది
రీజనింగ్ టెక్స్ట్ ఎల్లప్పుడూ సమాధానం నుండి వేరుగా ఉంటుంది. ప్రతి ఫార్మాట్కు దాని కోసం తన సొంత స్థానం ఉంది:
| ఎండ్పాయింట్ | స్ట్రీమ్ కాదు | స్ట్రీమ్ చేసినది |
|---|---|---|
/v1/chat/completions | choices[0].message.reasoning_content: ఒక string, లేదా మోడల్ ఏదీ ఇవ్వనప్పుడు null. | delta.content ఉన్న చంక్ల ముందు, choices[0].delta.reasoning_content ఉన్న చంక్లు. |
/v1/responses | message ఐటెమ్ ముందు output ఐటెమ్ {"type": "reasoning", "summary": [{"type": "summary_text", "text": "…"}]}. రీజనింగ్ లేనప్పుడు ఐటెమ్ ఉండదు. | reasoning ఐటెమ్తో response.output_item.added, ఆపై response.reasoning_summary_text.delta ఈవెంట్లు మరియు ఒక response.reasoning_summary_text.done. |
/v1/messages | మొదటి కంటెంట్ బ్లాక్ {"type": "thinking", "thinking": "…"}, ఆ తర్వాత text బ్లాక్. రీజనింగ్ లేనప్పుడు 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}
}
} {
"output": [
{
"id": "rs_6f0a2c4e8b1d4f3a9c7e5b3d1f8a6c4e",
"type": "reasoning",
"summary": [
{
"type": "summary_text",
"text": "Try small primes. 221 / 13 = 17, so 221 = 13 x 17."
}
]
},
{
"id": "msg_1b3d5f7a9c2e4b6d8f0a2c4e6b8d0f1a",
"type": "message",
"role": "assistant",
"status": "completed",
"content": [
{
"type": "output_text",
"text": "No. 221 = 13 x 17, so it is not prime.",
"annotations": []
}
]
}
],
"usage": {
"input_tokens": 14,
"input_tokens_details": {"cached_tokens": 0},
"output_tokens": 43,
"output_tokens_details": {"reasoning_tokens": 27},
"total_tokens": 57
}
} {
"content": [
{
"type": "thinking",
"thinking": "Try small primes. 221 / 13 = 17, so 221 = 13 x 17."
},
{"type": "text", "text": "No. 221 = 13 x 17, so it is not prime."}
],
"stop_reason": "end_turn",
"usage": {
"input_tokens": 14,
"cache_read_input_tokens": 0,
"cache_creation_input_tokens": 0,
"output_tokens": 43
}
} మోడల్ వారీగా ఎక్కడ చూడాలి:
| మోడల్స్ | టెక్స్ట్ ఎక్కడ వస్తుంది |
|---|---|
| హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్ | ప్రతి ఎండ్పాయింట్లో, స్ట్రీమ్ అయినా కాకపోయినా. effort off ఉన్న, లేదా response_format / text.format ఉన్న రిక్వెస్ట్కు రీజనింగ్ టెక్స్ట్ లేకుండా సమాధానం వస్తుంది. |
shannon-3, shannon-3-pro, shannon-3.1, shannon-3.1-pro | ప్రతి ఎండ్పాయింట్లో, స్ట్రీమ్ అయినా కాకపోయినా, మోడల్ రీజనింగ్ టెక్స్ట్ను ఇచ్చినప్పుడల్లా. |
shannon-2-lite, shannon-2-pro | /v1/chat/completions, స్ట్రీమ్ కాకుండా: message.reasoning_content లో. tools లేదా response_format లేని రిక్వెస్ట్లో స్ట్రీమ్ చేసినప్పుడు: మోడల్ రీజనింగ్ చేస్తున్నప్పుడు స్ట్రీమ్ : thinking కామెంట్ లైన్లను తీసుకువస్తుంది, ఆ తర్వాత సమాధాన చంక్లు. /v1/messages, స్ట్రీమ్ చేసినప్పుడు: టెక్స్ట్ బ్లాక్ ముందు thinking బ్లాక్. |
shannon-1.6-pro, shannon-coder-1 | స్ట్రీమ్ చేసిన సమాధానాలలో మరియు tools ఉన్న రిక్వెస్ట్ల సమాధానాలలో, మోడల్ రీజనింగ్ టెక్స్ట్ను ఇచ్చినప్పుడల్లా. |
/v1/responses లో, స్ట్రీమ్ కాని సమాధానం Shannon 3 ఫ్యామిలీ మరియు హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్కు reasoning ఐటెమ్ను కలిగి ఉంటుంది.
స్ట్రీమ్ను చదవడం
స్ట్రీమ్లో రీజనింగ్ టెక్స్ట్ మొదట, ప్రత్యేక డెల్టాలలో వస్తుంది, ఆ తర్వాత సమాధానం. ఆ రెండింటినీ విడివిడిగా ప్రింట్ చేయండి లేదా నిల్వ చేయండి:
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 import OpenAI from "openai";
const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://api.shannon-ai.com/v1" });
const stream = await client.chat.completions.create({
model: "Kimi-K3-3BIT-REAP",
reasoning_effort: "medium",
stream: true,
messages: [{ role: "user", content: "Is 221 a prime number?" }],
});
for await (const chunk of stream) {
const delta = chunk.choices[0]?.delta ?? {};
if (delta.reasoning_content) process.stdout.write(delta.reasoning_content); // the reasoning text comes first
if (delta.content) process.stdout.write(delta.content); // then the answer
} curl -N https://api.shannon-ai.com/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "Kimi-K3-3BIT-REAP",
"reasoning_effort": "medium",
"stream": true,
"messages": [
{"role": "user", "content": "Is 221 a prime number?"}
]
}' హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్ యొక్క మొదటి చంక్, రీజనింగ్ అయినా సమాధానం అయినా, delta.role: "assistant" ను కూడా కలిగి ఉంటుంది. స్ట్రీమింగ్
రీజనింగ్ tokens మరియు బిల్లింగ్
హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్లో, రీజనింగ్ 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 | రీజనింగ్ మరియు సమాధానం కలిపి. ఈ ఫార్మాట్కు ప్రత్యేక లెక్క లేదు. |
- హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్లో
max_tokensసమాధాన టెక్స్ట్ను పరిమితం చేస్తుంది. రీజనింగ్ tokens దీనికి లెక్కించబడవు. - రీజనింగ్ అవుట్పుట్గా బిల్ చేయబడుతుంది కాబట్టి, effort స్థాయి ఖర్చు సెట్టింగ్ కూడా:
offరీజనింగ్ tokens ను ఉత్పత్తి చేయదు. - Shannon మోడల్స్
prompt_tokens,completion_tokensమరియుtotal_tokens(/v1/messagesలోinput_tokensమరియుoutput_tokens) ను రీజనింగ్ వాటా లేకుండా నివేదిస్తాయి, మరియు ప్రతి token కు ఒకే ఫ్లాట్ ధరను బిల్ చేస్తాయి. మోడల్స్ & ధరలు
తదుపరి రిక్వెస్ట్లో రీజనింగ్
రీజనింగ్ను తిరిగి పంపాల్సిన అవసరం లేదు. మీరు పంపే సంభాషణలోని thinking బ్లాక్ లేదా reasoning ఐటెమ్ మోడల్కు అందించబడదు, కాబట్టి assistant టర్న్ను దానితో లేదా లేకుండా తిరిగి పంపవచ్చు. thinking బ్లాక్కు type మరియు thinking అనే రెండు ఫీల్డ్లు ఉంటాయి; దానికి signature లేదు.
ఎరర్లు
| స్టేటస్ | రకం | మెసేజ్ | ఎప్పుడు |
|---|---|---|---|
400 | invalid_request_error | unknown reasoning effort '<value>'; expected off, low, medium or high | హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్ జాబితా వెలుపల విలువను, ఉదాహరణకు xhigh, అందుకుంది. మీ బ్యాలెన్స్ నుండి ఏదీ తీసుకోబడదు. |
422 | invalid_request_error | Failed to deserialize the JSON body into the target type: … | reasoning_effort ఒక string కాదు. |
ఆథెంటికేషన్, బ్యాలెన్స్ మరియు సర్వర్ ఎరర్లు ప్రతి రిక్వెస్ట్కు ఉన్నవే. ఎరర్ హ్యాండ్లింగ్