ਸਮੱਗਰੀ ਤੇ ਜਾਓ
Anthropic

Anthropic

POST /v1/messages Anthropic Messages ਫਾਰਮੈਟ ਵਿੱਚ ਰਿਕੁਐਸਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਉਸੇ ਫਾਰਮੈਟ ਵਿੱਚ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਸਟ੍ਰੀਮ ਹੋ ਕੇ ਜਾਂ ਬਿਨਾਂ। ਇਸ ਨੂੰ Anthropic SDK ਨਾਲ ਅਤੇ ਉਸ ਉੱਤੇ ਬਣੇ ਟੂਲਾਂ ਨਾਲ ਵਰਤੋ, ਜਿਵੇਂ Claude Code: base URL ਸੈੱਟ ਕਰੋ, ਆਪਣੀ Shannon API key ਵਰਤੋ ਅਤੇ ਇੱਕ Shannon ਮਾਡਲ id ਦਿਓ।

POST https://api.shannon-ai.com/v1/messages

Anthropic SDK ਨੂੰ Shannon ਦੇ base URL ਵੱਲ ਕਰੋ। SDK /v1/messages ਆਪ ਜੋੜ ਲੈਂਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡੀ key x-api-key ਹੈਡਰ ਵਿੱਚ ਭੇਜਦਾ ਹੈ।

import anthropic

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

message = client.messages.create(
    model="shannon-3",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Say hello in one sentence."}],
)

for block in message.content:
    if block.type == "text":
        print(block.text)

ਜਵਾਬ ਇੱਕ message ਹੈ ਜਿਸ ਦਾ content blocks ਦੀ ਸੂਚੀ ਹੈ। Blocks ਨੂੰ ਉਨ੍ਹਾਂ ਦੇ type ਤੋਂ ਲੱਭੋ: ਜਦੋਂ ਮਾਡਲ ਨੇ ਰੀਜ਼ਨਿੰਗ ਕੀਤੀ ਹੋਵੇ, ਪਹਿਲਾ block thinking ਹੁੰਦਾ ਹੈ ਅਤੇ ਟੈਕਸਟ ਉਸ ਤੋਂ ਬਾਅਦ ਆਉਂਦਾ ਹੈ।

200 JSON
{
  "id": "msg_5f0c1e7a9b3d4c62a8e1f07d2b46c9a3",
  "type": "message",
  "role": "assistant",
  "model": "shannon-3",
  "content": [
    {
      "type": "thinking",
      "thinking": "The user wants a greeting in one sentence. Keep it short and friendly."
    },
    {
      "type": "text",
      "text": "Hello, it is good to meet you."
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 1184,
    "output_tokens": 46
  }
}

Headers

Header ਮੁੱਲ ਵੇਰਵਾ
x-api-key YOUR_API_KEY ਤੁਹਾਡੀ API key। ਇਸ ਦੀ ਥਾਂ Authorization: Bearer YOUR_API_KEY ਵੀ ਸਵੀਕਾਰ ਹੈ।
content-type application/json ਲਾਜ਼ਮੀ।
anthropic-version 2023-06-01 ਸਵੀਕਾਰ ਹੈ, ਲਾਜ਼ਮੀ ਨਹੀਂ। Anthropic SDK 2023-06-01 ਭੇਜਦਾ ਹੈ; ਮੁੱਲ ਜੋ ਵੀ ਹੋਵੇ, ਜਵਾਬ ਦਾ ਫਾਰਮੈਟ ਉਹੀ ਰਹਿੰਦਾ ਹੈ।
anthropic-beta ਸਵੀਕਾਰ ਹੈ, ਲਾਜ਼ਮੀ ਨਹੀਂ।
x-request-id ਵਿਕਲਪਿਕ। ਰਿਕੁਐਸਟ ਲਈ ਤੁਹਾਡੀ ਆਪਣੀ id। ਇਹ ਜਵਾਬ ਵਿੱਚ ਬਿਨਾਂ ਬਦਲੇ ਵਾਪਸ ਆਉਂਦੀ ਹੈ; ਇਸ ਤੋਂ ਬਿਨਾਂ ਜਵਾਬ ਵਿੱਚ 12 ਹੈਕਸਾਡੈਸੀਮਲ ਅੱਖਰਾਂ ਦੀ id ਹੁੰਦੀ ਹੈ।

ਰਿਕੁਐਸਟ fields

ਸਿਰਫ਼ messages ਲਾਜ਼ਮੀ ਹੈ। ਲਾਗੂ ਕਰਨ ਵਾਲੇ ਕਾਲਮ ਉਹ ਮਾਡਲ ਦੱਸਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਉੱਤੇ ਕੋਈ field ਜਵਾਬ ਨੂੰ ਬਦਲਦਾ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਮਾਡਲ ਸੂਚੀ ਦੀਆਂ ਬਾਰਾਂ id ਹਨ; Shannon 3 ਪਰਿਵਾਰ shannon-3, shannon-3-pro, shannon-3.1 ਅਤੇ shannon-3.1-pro ਹੈ। ਮਾਡਲ ਅਤੇ ਕੀਮਤਾਂ

Field ਕਿਸਮ ਡਿਫੌਲਟ ਵੇਰਵਾ ਲਾਗੂ ਕਰਨ ਵਾਲੇ
model string shannon-1.6-lite ਮਾਡਲ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ Shannon ਮਾਡਲ id। ਇਸ ਨੂੰ ਹਰ ਰਿਕੁਐਸਟ ਨਾਲ ਭੇਜੋ। ਮਿਲਾਨ ਵੱਡੇ-ਛੋਟੇ ਅੱਖਰਾਂ ਉੱਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦਾ। ਕੋਈ ਹੋਰ ਨਾਂ 400 unknown model ਮੋੜਦਾ ਹੈ, ਇਸ ਲਈ ਜੋ ਟੂਲ ਆਪਣੇ ਮਾਡਲ ਨਾਂ ਭੇਜਦਾ ਹੈ ਉਸ ਨੂੰ Shannon id ਉੱਤੇ ਸੈੱਟ ਕਰਨਾ ਪਵੇਗਾ। ਸਾਰੇ ਮਾਡਲ
messages array ਲਾਜ਼ਮੀ। ਗੱਲਬਾਤ, ਸਭ ਤੋਂ ਪੁਰਾਣਾ message ਪਹਿਲਾਂ, user ਅਤੇ assistant ਭੂਮਿਕਾਵਾਂ ਨਾਲ। ਹੇਠਾਂ Messages ਅਤੇ ਸਮੱਗਰੀ blocks ਵੇਖੋ। ਸਾਰੇ ਮਾਡਲ
system string | array ਮਾਡਲ ਲਈ ਹਦਾਇਤਾਂ: ਇੱਕ string, ਜਾਂ text blocks ਦਾ array। ਹੇਠਾਂ System prompt ਵੇਖੋ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ, shannon-1.6-*, shannon-2-*, shannon-coder-1
max_tokens integer 4096 ਜਵਾਬ ਦੀ ਉੱਪਰਲੀ ਸੀਮਾ, ਟੋਕਨਾਂ ਵਿੱਚ। ਇਸ endpoint ਉੱਤੇ ਵਿਕਲਪਿਕ; Anthropic SDK ਇਸ ਨੂੰ ਹਮੇਸ਼ਾ ਭੇਜਦਾ ਹੈ। 1 ਤੋਂ 65,536 ਤੋਂ ਬਾਹਰਲਾ ਮੁੱਲ ਇਸ ਦਾਇਰੇ ਵਿੱਚ ਲੈ ਆਂਦਾ ਜਾਂਦਾ ਹੈ। ਰਿਕੁਐਸਟ ਚੱਲਣ ਦੌਰਾਨ ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਵਿੱਚੋਂ ਇੰਨੀ ਮਾਤਰਾ ਅਲੱਗ ਰੱਖੀ ਜਾਂਦੀ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1
stream boolean false true ਜਵਾਬ ਨੂੰ server-sent events ਵਜੋਂ ਭੇਜਦਾ ਹੈ। ਹੇਠਾਂ ਸਟ੍ਰੀਮਿੰਗ ਵੇਖੋ। ਸਾਰੇ ਮਾਡਲ
temperature number Sampling temperature। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ ਮੁੱਲ 0 ਅਤੇ 2 ਦੇ ਵਿਚਕਾਰ ਰੱਖੇ ਜਾਂਦੇ ਹਨ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1
top_p number Nucleus sampling। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ
stop_sequences array 4 ਤੱਕ strings। ਜਵਾਬ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਪਹਿਲੀ ਦਿਖਣ ਵਾਲੀ ਤੋਂ ਪਹਿਲਾਂ ਖ਼ਤਮ ਹੋ ਜਾਂਦਾ ਹੈ। stop_reason end_turn ਹੀ ਰਹਿੰਦਾ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ
tools array ਉਹ ਟੂਲ ਜੋ ਮਾਡਲ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ, ਹਰੇਕ {"name", "description", "input_schema"} ਵਜੋਂ। ਹੇਠਾਂ Tools ਵੇਖੋ। ਸਾਰੇ ਮਾਡਲ
tool_choice object {"type": "auto"} ਮਾਡਲ ਨੂੰ ਫ਼ੈਸਲਾ ਕਰਨ ਦਿੰਦਾ ਹੈ, {"type": "any"} ਉਸ ਤੋਂ ਕੋਈ ਟੂਲ ਕਾਲ ਕਰਵਾਉਂਦਾ ਹੈ, {"type": "tool", "name": "…"} ਉਸ ਤੋਂ ਉਹੀ ਟੂਲ ਕਾਲ ਕਰਵਾਉਂਦਾ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ
thinking object ਜਵਾਬ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਮਾਡਲ ਕਿੰਨੀ ਰੀਜ਼ਨਿੰਗ ਕਰਦਾ ਹੈ। ਹੇਠਾਂ Thinking ਵੇਖੋ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ
web_search boolean false ਫਾਰਮੈਟ ਵਿੱਚ Shannon ਦਾ ਜੋੜ: true ਮਾਡਲ ਨੂੰ ਜਵਾਬ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਵੈੱਬ ਖੋਜਣ ਦਿੰਦਾ ਹੈ। shannon-1.6-*, shannon-2-*, Shannon 3 ਪਰਿਵਾਰ

max_tokens ਤੋਂ ਬਿਨਾਂ ਮੁੱਲ 4,096 ਹੁੰਦਾ ਹੈ, ਅਤੇ shannon-coder-1 ਉੱਤੇ 65,536।

ਬਲਾਕਾਂ ਉੱਤੇ metadata, top_k, service_tier ਅਤੇ cache_control ਮਾਰਕਰ ਸਵੀਕਾਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਤਾਂ ਜੋ ਮੌਜੂਦਾ ਕਲਾਇੰਟ ਕੋਡ ਬਿਨਾਂ ਬਦਲਾਅ ਦੇ ਚੱਲੇ। ਇਹ ਜਵਾਬ ਨੂੰ ਨਹੀਂ ਬਦਲਦੇ; ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ ਪ੍ਰੋਂਪਟ ਕੈਸ਼ਿੰਗ ਆਪਣੇ-ਆਪ ਹੁੰਦੀ ਹੈ।

ਕਿਸੇ schema ਅਨੁਸਾਰ JSON ਜਵਾਬ Chat Completions ਉੱਤੇ response_format ਨਾਲ ਅਤੇ Responses ਉੱਤੇ text.format ਨਾਲ ਮੰਗਿਆ ਜਾਂਦਾ ਹੈ। ਸਟ੍ਰਕਚਰਡ ਆਉਟਪੁੱਟਸ

System prompt ਅਤੇ thinking ਵਾਲੀ ਰਿਕੁਐਸਟ

ਇਹ ਰਿਕੁਐਸਟ ਇੱਕ system prompt, ਇੱਕ thinking budget, ਇੱਕ temperature ਅਤੇ ਇੱਕ stop sequence ਭੇਜਦੀ ਹੈ। ਇਹ ਇੱਕ ਹੋਸਟ ਕੀਤਾ open-weight ਮਾਡਲ ਵਰਤਦੀ ਹੈ, ਜੋ ਇਨ੍ਹਾਂ ਸਭ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।

import anthropic

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

message = client.messages.create(
    model="DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    max_tokens=4096,
    system="You are a physics teacher. Answer in two sentences.",
    thinking={"type": "enabled", "budget_tokens": 2048},
    temperature=0.3,
    stop_sequences=["\n\n"],
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
)

for block in message.content:
    if block.type == "thinking":
        print("reasoning:", block.thinking)
    elif block.type == "text":
        print("answer:", block.text)
print(message.usage)

ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ usage ਪ੍ਰੋਂਪਟ ਕੈਸ਼ ਤੋਂ ਪੜ੍ਹੇ ਟੋਕਨਾਂ ਨੂੰ ਬਾਕੀ ਇਨਪੁਟ ਟੋਕਨਾਂ ਤੋਂ ਅਲੱਗ ਦੱਸਦਾ ਹੈ।

200 JSON
{
  "usage": {
    "input_tokens": 31,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0,
    "output_tokens": 62
  }
}

System prompt

system ਇੱਕ string ਹੈ, ਜਾਂ [{"type": "text", "text": "…"}] ਰੂਪ ਵਿੱਚ text blocks ਦਾ array। Blocks ਦੇ ਟੈਕਸਟ ਇੱਕ ਲਾਈਨ ਬ੍ਰੇਕ ਨਾਲ ਜੋੜੇ ਜਾਂਦੇ ਹਨ।

ਇਹ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ, shannon-1.6-lite, shannon-1.6-pro, shannon-2-lite, shannon-2-pro ਅਤੇ shannon-coder-1 ਉੱਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। Shannon 3 ਪਰਿਵਾਰ ਦੀ id ਨਾਲ, ਜੋ ਹਦਾਇਤਾਂ ਲਾਜ਼ਮੀ ਹਨ ਉਨ੍ਹਾਂ ਨੂੰ user message ਵਿੱਚ ਪਾਓ।

Messages ਅਤੇ ਸਮੱਗਰੀ blocks

ਇੱਕ message ਵਿੱਚ role, ਯਾਨੀ user ਜਾਂ assistant, ਅਤੇ ਇੱਕ content ਹੁੰਦਾ ਹੈ। content ਇੱਕ string ਹੈ, ਜਾਂ blocks ਦਾ array।

Block ਵੇਰਵਾ ਉਪਲਬਧ ਹੈ
{"type": "text", "text": "…"} ਟੈਕਸਟ। ਸਾਰੇ ਮਾਡਲ
{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": "…"}}
{"type": "image", "source": {"type": "url", "url": "…"}}
user message ਵਿੱਚ ਇੱਕ ਚਿੱਤਰ, base64 ਵਜੋਂ ਜਾਂ URL ਦੁਆਰਾ। Shannon 3 ਪਰਿਵਾਰ, shannon-1.6-lite, shannon-1.6-pro, ਅਤੇ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਜੋ ਚਿੱਤਰ ਇਨਪੁਟ ਦੱਸਦੇ ਹਨ
{"type": "document", "source": {"type": "base64", "media_type": "application/pdf", "data": "…"}} user message ਵਿੱਚ ਇੱਕ ਦਸਤਾਵੇਜ਼ (PDF, Word, PowerPoint ਜਾਂ Excel), base64 ਵਜੋਂ ਜਾਂ URL ਦੁਆਰਾ। Shannon 3 ਪਰਿਵਾਰ
{"type": "tool_use", "id": "toolu_…", "name": "…", "input": {…}} assistant message ਵਿੱਚ: ਇੱਕ tool call ਜੋ ਮਾਡਲ ਨੇ ਪਿਛਲੇ ਜਵਾਬ ਵਿੱਚ ਕੀਤੀ ਸੀ। ਸਾਰੇ ਮਾਡਲ
{"type": "tool_result", "tool_use_id": "toolu_…", "content": "…"} user message ਵਿੱਚ: ਉਸ ਕਾਲ ਦਾ ਨਤੀਜਾ। content ਇੱਕ string ਹੈ, ਜਾਂ text blocks ਦੀ ਸੂਚੀ। ਸਾਰੇ ਮਾਡਲ

ਤੁਸੀਂ ਪਿਛਲੇ ਜਵਾਬ ਦਾ content ਜਿਉਂ ਦਾ ਤਿਉਂ ਵਾਪਸ ਭੇਜ ਸਕਦੇ ਹੋ: text ਅਤੇ tool_use blocks ਪੜ੍ਹੇ ਜਾਂਦੇ ਹਨ, thinking blocks ਛੱਡ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।

Shannon ਟੀਅਰਾਂ ਉੱਤੇ ਚਿੱਤਰ ਅਤੇ ਦਸਤਾਵੇਜ਼ ਆਖਰੀ user message ਵਿੱਚੋਂ ਪੜ੍ਹੇ ਜਾਂਦੇ ਹਨ। ਆਕਾਰ ਅਤੇ ਸੀਮਾਵਾਂ ਦਾ ਆਪਣਾ ਪੰਨਾ ਹੈ। ਇਮੇਜਾਂ ਅਤੇ ਫਾਈਲਾਂ

Thinking

ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ thinking ਨੂੰ ਰੀਜ਼ਨਿੰਗ effort ਨਾਲ ਜੋੜਦੇ ਹਨ। ਇਸ ਫੀਲਡ ਤੋਂ ਬਿਨਾਂ effort ਉੱਚਾ ਹੁੰਦਾ ਹੈ।

ਰੂਪ budget_tokens ਪ੍ਰਭਾਵ
{"type": "disabled"} ਕੋਈ ਰੀਜ਼ਨਿੰਗ ਨਹੀਂ। ਜਵਾਬ ਵਿੱਚ ਕੋਈ thinking block ਨਹੀਂ ਹੁੰਦਾ।
{"type": "enabled", "budget_tokens": 2048} ≤ 2,048 ਘੱਟ effort।
{"type": "enabled", "budget_tokens": 8192} ≤ 8,192 ਦਰਮਿਆਨਾ effort।
{"type": "enabled", "budget_tokens": 16000} > 8,192 ਉੱਚਾ effort।

ਰੀਜ਼ਨਿੰਗ ਕਰਨ ਵਾਲਾ ਮਾਡਲ ਆਪਣੀ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਤੋਂ ਪਹਿਲਾਂ {"type": "thinking", "thinking": "…"} block ਵਜੋਂ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਰੀਜ਼ਨਿੰਗ ਕਰਨ ਵਾਲੇ Shannon ਟੀਅਰ ਵੀ ਇਸ ਨੂੰ ਭੇਜਦੇ ਹਨ।

Efforts ਦਾ ਵੇਰਵਾ ਉਨ੍ਹਾਂ ਦੇ ਆਪਣੇ ਪੰਨੇ ਉੱਤੇ ਹੈ। ਰੀਜ਼ਨਿੰਗ effort

Tools

ਟੂਲ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜਿਸ ਨੂੰ ਤੁਹਾਡਾ ਕੋਡ ਚਲਾਉਂਦਾ ਹੈ। ਹਰ ਇੱਕ ਦਾ ਵਰਣਨ name, description ਅਤੇ input_schema ਨਾਲ ਕਰੋ। ਜਦੋਂ ਮਾਡਲ ਨੂੰ ਟੂਲ ਚਾਹੀਦਾ ਹੋਵੇ, ਜਵਾਬ ਵਿੱਚ tool_use block ਹੁੰਦਾ ਹੈ ਅਤੇ stop_reason tool_use ਹੁੰਦਾ ਹੈ।

tools ਵਿੱਚ ਇੱਕ ਟੂਲ ਪਰਿਭਾਸ਼ਾ:

tools
[
  {
    "name": "get_weather",
    "description": "Current weather for a city.",
    "input_schema": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string"
        }
      },
      "required": [
        "city"
      ]
    }
  }
]

ਉਸ ਨੂੰ ਕਾਲ ਕਰਨ ਵਾਲੇ ਜਵਾਬ ਦਾ content:

200 content
[
  {
    "type": "text",
    "text": ""
  },
  {
    "type": "tool_use",
    "id": "toolu_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
    "name": "get_weather",
    "input": {
      "city": "Paris"
    }
  }
]

ਟੂਲ ਚਲਾਓ, ਫਿਰ ਰਿਕੁਐਸਟ ਦੁਬਾਰਾ ਭੇਜੋ, ਜਿਸ ਵਿੱਚ messages ਵਿੱਚ ਕਾਲ ਅਤੇ ਇੱਕ tool_result block ਜੋੜਿਆ ਹੋਵੇ:

messages
[
  {
    "role": "user",
    "content": "What is the weather in Paris?"
  },
  {
    "role": "assistant",
    "content": [
      {
        "type": "tool_use",
        "id": "toolu_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
        "name": "get_weather",
        "input": {
          "city": "Paris"
        }
      }
    ]
  },
  {
    "role": "user",
    "content": [
      {
        "type": "tool_result",
        "tool_use_id": "toolu_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
        "content": "{\"temperature_c\": 18, \"sky\": \"cloudy\"}"
      }
    ]
  }
]

tool_choice

ਰੂਪ ਪ੍ਰਭਾਵ ਲਾਗੂ ਕਰਨ ਵਾਲੇ
{"type": "auto"} ਮਾਡਲ ਆਪ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਟੂਲ ਕਾਲ ਕਰਨਾ ਹੈ ਜਾਂ ਨਹੀਂ। ਇਹ ਡਿਫਾਲਟ ਹੈ। ਸਾਰੇ ਮਾਡਲ
{"type": "any"} ਮਾਡਲ ਨੂੰ ਟੂਲਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਨੂੰ ਕਾਲ ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ
{"type": "tool", "name": "…"} ਮਾਡਲ ਨੂੰ ਨਾਂ ਦਿੱਤੇ ਗਏ ਟੂਲ ਨੂੰ ਕਾਲ ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ

ਸਿਰਫ਼ input_schema ਵਾਲੇ ਟੂਲ ਪੜ੍ਹੇ ਜਾਂਦੇ ਹਨ। ਇਸ endpoint ਉੱਤੇ ਵੈੱਬ ਸਰਚ ਕੋਈ ਟੂਲ ਨਹੀਂ ਹੈ: web_search ਫੀਲਡ ਸੈੱਟ ਕਰੋ।

ਟੂਲ ਲੂਪ ਦਾ ਪੂਰਾ ਵੇਰਵਾ ਉਸ ਦੇ ਆਪਣੇ ਪੰਨੇ ਉੱਤੇ ਹੈ। ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ

ਜਵਾਬ

Field ਕਿਸਮ ਵੇਰਵਾ ਭੇਜਣ ਵਾਲਾ
id string msg_ ਤੋਂ ਬਾਅਦ 32 ਹੈਕਸਾਡੈਸੀਮਲ ਅੱਖਰ। ਸਾਰੇ ਮਾਡਲ
type string ਹਮੇਸ਼ਾ message। ਸਾਰੇ ਮਾਡਲ
role string ਹਮੇਸ਼ਾ assistant। ਸਾਰੇ ਮਾਡਲ
model string ਜਵਾਬ ਦੇਣ ਵਾਲੇ ਮਾਡਲ ਦੀ ਮਿਆਰੀ id। ਸਾਰੇ ਮਾਡਲ
content array ਜਵਾਬ ਦੇ blocks, ਇਸ ਕ੍ਰਮ ਵਿੱਚ: thinking ਜਦੋਂ ਮਾਡਲ ਨੇ ਰੀਜ਼ਨਿੰਗ ਕੀਤੀ, text, ਫਿਰ ਹਰ tool call ਲਈ ਇੱਕ tool_use। ਸਾਰੇ ਮਾਡਲ
stop_reason string ਜਵਾਬ ਕਿਉਂ ਖਤਮ ਹੋਇਆ। ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲ ਵੇਖੋ। ਸਾਰੇ ਮਾਡਲ
usage object input_tokens ਅਤੇ output_tokens। ਸਾਰੇ ਮਾਡਲ
sources array ਸਿਰਫ਼ ਉਸ ਰਿਕੁਐਸਟ ਉੱਤੇ ਜਿਸ ਵਿੱਚ web_search: true ਹੋਵੇ ਅਤੇ ਜਿਸਦੀ ਖੋਜ ਨੂੰ ਕੁਝ ਮਿਲਿਆ ਹੋਵੇ: ਮਾਡਲ ਨੂੰ ਦਿੱਤੇ ਨਤੀਜੇ, ਹਰ ਇੱਕ ਵਿੱਚ index, title ਅਤੇ url। ਜਵਾਬ ਵਿੱਚ [1] ਉਹ ਐਂਟਰੀ ਹੈ ਜਿਸਦਾ index 1 ਹੈ। ਸਟ੍ਰੀਮ ਵਿੱਚ ਇਹ message_delta ਇਵੈਂਟ ਨਾਲ ਆਉਂਦਾ ਹੈ। shannon-1.6-*, shannon-2-*, Shannon 3 ਪਰਿਵਾਰ
usage.cache_read_input_tokens integer cache_read_input_tokens ਪ੍ਰੋਂਪਟ ਦਾ ਉਹ ਹਿੱਸਾ ਹੈ ਜੋ ਕੈਸ਼ ਤੋਂ ਪੜ੍ਹਿਆ ਗਿਆ; input_tokens ਬਾਕੀ ਹੈ। cache_creation_input_tokens ਹਮੇਸ਼ਾ 0 ਹੁੰਦਾ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ

ਜਵਾਬ ਦੇ blocks

Block ਵੇਰਵਾ
{"type": "thinking", "thinking": "…"} ਮਾਡਲ ਦੀ ਰੀਜ਼ਨਿੰਗ। ਇਸ ਵਿੱਚ signature member ਨਹੀਂ ਹੁੰਦਾ।
{"type": "text", "text": "…"} ਜਵਾਬ ਦਾ ਟੈਕਸਟ। ਜਦੋਂ ਜਵਾਬ ਇੱਕ tool call ਹੋਵੇ ਤਾਂ ਇਹ ਖਾਲੀ ਹੋ ਸਕਦਾ ਹੈ।
{"type": "tool_use", "id": "toolu_…", "name": "…", "input": {…}} ਇੱਕ tool call। input ਇੱਕ JSON object ਹੈ। ਨਤੀਜਾ ਉਸੇ id ਨਾਲ ਵਾਪਸ ਭੇਜੋ।

stop_reason

stop_reason ਵੇਰਵਾ ਭੇਜਣ ਵਾਲਾ
end_turn ਮਾਡਲ ਨੇ ਆਪਣਾ ਜਵਾਬ ਪੂਰਾ ਕੀਤਾ, ਜਾਂ ਤੁਹਾਡੀਆਂ stop_sequences ਵਿੱਚੋਂ ਇੱਕ ਦਿਖਾਈ ਦਿੱਤੀ। ਸਾਰੇ ਮਾਡਲ
tool_use ਜਵਾਬ ਵਿੱਚ ਇੱਕ ਜਾਂ ਵੱਧ tool calls ਹਨ। ਸਾਰੇ ਮਾਡਲ
max_tokens ਜਵਾਬ ਆਉਟਪੁੱਟ ਦੀ ਸੀਮਾ ਉੱਤੇ ਕੱਟ ਦਿੱਤਾ ਗਿਆ। Shannon 3 ਪਰਿਵਾਰ, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1, ਸਟ੍ਰੀਮਾਂ ਵਿੱਚ

ਸਟ੍ਰੀਮਿੰਗ

server-sent events ਲਈ stream ਨੂੰ true ਕਰੋ। ਹਰ frame ਵਿੱਚ event ਦੇ ਨਾਂ ਵਾਲੀ ਇੱਕ event: ਲਾਈਨ ਅਤੇ ਇੱਕ data: ਲਾਈਨ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ JSON object ਹੁੰਦਾ ਹੈ ਜੋ ਨਾਂ ਨੂੰ type ਵਿੱਚ ਦੁਹਰਾਉਂਦਾ ਹੈ। Anthropic SDK ਦੇ stream helpers ਇਹ events ਤੁਹਾਡੇ ਲਈ ਪੜ੍ਹ ਲੈਂਦੇ ਹਨ:

import anthropic

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

with client.messages.stream(
    model="shannon-3",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain server-sent events in three sentences."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    message = stream.get_final_message()

print()
print(message.stop_reason, message.usage)

Events, ਉਸ ਕ੍ਰਮ ਵਿੱਚ ਜਿਸ ਵਿੱਚ ਉਹ ਪਹੁੰਚਦੇ ਹਨ:

Event ਡੇਟਾ ਕਦੋਂ
message_start message ਹਮੇਸ਼ਾ ਸਭ ਤੋਂ ਪਹਿਲਾਂ। message ਵਿੱਚ id, role, ਮਾਡਲ, ਖਾਲੀ content ਅਤੇ ਇੱਕ usage ਹੁੰਦੀ ਹੈ ਜੋ ਸਿਫ਼ਰ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ।
content_block_start index, content_block ਇੱਕ block ਖੁੱਲ੍ਹਦਾ ਹੈ। content_block ਇੱਕ ਖਾਲੀ text ਜਾਂ thinking block ਹੈ, ਜਾਂ ਆਪਣੇ id ਅਤੇ name ਸਮੇਤ ਇੱਕ tool_use block।
content_block_delta index, delta {"type": "thinking_delta", "thinking"} thinking block ਲਈ, ਰੀਜ਼ਨਿੰਗ ਦਾ ਇੱਕ ਟੁਕੜਾ।
content_block_delta index, delta {"type": "text_delta", "text"} text block ਲਈ, ਜਵਾਬ ਦਾ ਇੱਕ ਟੁਕੜਾ।
content_block_delta index, delta {"type": "input_json_delta", "partial_json"} tool_use block ਲਈ: ਟੂਲ ਕਾਲ ਦੇ ਪੂਰੇ ਆਰਗੂਮੈਂਟ, ਇੱਕੋ ਡੈਲਟਾ ਵਿੱਚ।
content_block_stop index ਇਸ index ਵਾਲਾ block ਪੂਰਾ ਹੋ ਗਿਆ।
message_delta delta {stop_reason, stop_sequence}, usage ਜਵਾਬ ਦਾ ਅੰਤ: delta.stop_reason, ਅਤੇ ਰਿਕੁਐਸਟ ਦੀ usage।
message_stop ਹਮੇਸ਼ਾ ਸਭ ਤੋਂ ਅਖੀਰ ਵਿੱਚ।

Blocks ਨੂੰ index ਨਾਲ ਉਸ ਕ੍ਰਮ ਵਿੱਚ ਨੰਬਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ ਜਿਸ ਵਿੱਚ ਉਹ ਖੁੱਲ੍ਹਦੇ ਹਨ, ਅਤੇ ਇੱਕ block ਅਗਲਾ ਖੁੱਲ੍ਹਣ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ। ਹਰ block ਨੂੰ ਉਸ ਦੀ ਕਿਸਮ ਤੋਂ ਪੜ੍ਹੋ, ਨੰਬਰ ਤੋਂ ਨਹੀਂ: ਇੱਕ stream ਪਹਿਲਾਂ ਖਾਲੀ text block ਖੋਲ੍ਹ ਸਕਦੀ ਹੈ, ਫਿਰ thinking block, ਅਤੇ ਜਵਾਬ ਬਾਅਦ ਦੇ ਕਿਸੇ text block ਵਿੱਚ ਦੇ ਸਕਦੀ ਹੈ।

200 text/event-stream
event: message_start
data: {"type":"message_start","message":{"id":"msg_5f0c…","type":"message","role":"assistant","model":"shannon-3","content":[],"usage":{"input_tokens":0,"output_tokens":0}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: content_block_start
data: {"type":"content_block_start","index":1,"content_block":{"type":"thinking","thinking":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":1,"delta":{"type":"thinking_delta","thinking":"Three sentences: what it is, how it is framed, why it is used."}}

event: ping
data: {"type": "ping"}

event: content_block_stop
data: {"type":"content_block_stop","index":1}

event: content_block_start
data: {"type":"content_block_start","index":2,"content_block":{"type":"text","text":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":2,"delta":{"type":"text_delta","text":"Server-sent events let a server push text over one HTTP reply."}}

event: content_block_stop
data: {"type":"content_block_stop","index":2}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"input_tokens":1190,"output_tokens":84}}

event: message_stop
data: {"type":"message_stop"}

Keep-alive

ਭੇਜਣ ਵਾਲਾ ਵੇਰਵਾ
Shannon 3 ਪਰਿਵਾਰ, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1 ਇੱਕ ping event, ਜਿਸ ਦਾ data {"type": "ping"} ਹੈ, ਹਰ 15 ਸਕਿੰਟ ਬਾਅਦ।
ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਇੱਕ ਟਿੱਪਣੀ ਲਾਈਨ : keepalive, ਜਦੋਂ ਤੱਕ ਮਾਡਲ ਕੰਮ ਕਰਦਾ ਹੈ ਹਰ 15 ਸਕਿੰਟ ਬਾਅਦ।

ਅਸਫਲ ਹੋਣ ਵਾਲੀ stream

stream ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਆਈ ਅਸਫਲਤਾ ਇੱਕ error event ਹੁੰਦੀ ਹੈ, ਜਿਸ ਦੀ body ਗਲਤੀ ਵਾਲੇ ਜਵਾਬ ਵਾਲੀ ਹੀ ਹੁੰਦੀ ਹੈ: {"type": "error", "error": {"type", "message"}}। ਬੰਦ ਕਰਨ ਵਾਲੇ events, message_delta ਅਤੇ message_stop, ਫਿਰ ਵੀ ਪਿੱਛੇ ਆਉਂਦੇ ਹਨ। ਜਵਾਬ ਨੂੰ ਅਸਫਲ ਮੰਨੋ ਅਤੇ ਰਿਕੁਐਸਟ ਦੁਬਾਰਾ ਭੇਜੋ।

ਗਲਤੀਆਂ

ਗਲਤੀਆਂ Anthropic ਗਲਤੀ body ਵਰਤਦੀਆਂ ਹਨ: type ਦਾ ਮੁੱਲ error ਹੁੰਦਾ ਹੈ, ਅਤੇ error object ਵਿੱਚ ਇੱਕ type ਅਤੇ ਇੱਕ message ਹੁੰਦੇ ਹਨ। ਸਾਰਣੀ ਉਹ ਦੱਸਦੀ ਹੈ ਜੋ ਇਹ endpoint ਸਭ ਤੋਂ ਵੱਧ ਮੋੜਦਾ ਹੈ। ਪੂਰੀ ਸੂਚੀ, ਇਸ ਸਮੇਤ ਕਿ ਕਿਸ ਨੂੰ ਦੁਬਾਰਾ ਅਜ਼ਮਾਉਣਾ ਹੈ, ਦਾ ਆਪਣਾ ਪੰਨਾ ਹੈ। ਗਲਤੀਆਂ

400 JSON
{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "unknown model: no-such-model"
  }
}
ਸਟੇਟਸ ਕਿਸਮ Message ਕਦੋਂ
401 authentication_error Missing authentication
Invalid API key
ਕੋਈ API key ਨਹੀਂ ਭੇਜੀ ਗਈ, ਜਾਂ key ਅਣਜਾਣ ਹੈ ਜਾਂ ਰੱਦ ਕੀਤੀ ਗਈ ਹੈ।
400 invalid_request_error unknown model: <id> model ਕੋਈ Shannon ਮਾਡਲ id ਨਹੀਂ ਹੈ।
400 invalid_request_error No user message provided Shannon ਟੀਅਰ: ਰਿਕੁਐਸਟ ਵਿੱਚ ਕੋਈ ਉਪਭੋਗਤਾ ਟੈਕਸਟ ਨਹੀਂ ਹੈ ਅਤੇ ਕੋਈ tools ਨਹੀਂ ਹਨ।
400 invalid_request_error <id> does not accept image input ਚਿੱਤਰ ਇਨਪੁਟ ਤੋਂ ਬਿਨਾਂ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਨੂੰ ਚਿੱਤਰ ਭੇਜਿਆ ਗਿਆ।
422 invalid_request_error Failed to deserialize the JSON body into the target type: … messages ਗੁੰਮ ਹੈ, ਜਾਂ ਕਿਸੇ field ਦੀ JSON ਕਿਸਮ ਗਲਤ ਹੈ।
429 rate_limit_error Quota exceeded. Upgrade your plan at shannon-ai.com/plan max_tokens ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਵਿੱਚ ਬਚੇ ਹੋਏ ਨਾਲੋਂ ਵੱਡਾ ਹੈ।
429 rate_limit_error Too many requests. Retry in <n>s. ਫਲੱਡ ਪ੍ਰੋਟੈਕਸ਼ਨ: ਤੁਹਾਡੇ ਖਾਤੇ ਉੱਤੇ ਇੱਕ ਮਿੰਟ ਵਿੱਚ 120 ਤੋਂ ਵੱਧ ਰਿਕੁਐਸਟਾਂ।
429 rate_limit_error Shannon Coder call quota reached. Upgrade your plan at shannon-ai.com/plan shannon-coder-1: ਮੌਜੂਦਾ 4-ਘੰਟੇ ਦੀ ਵਿੰਡੋ ਲਈ ਤੁਹਾਡੇ ਪਲਾਨ ਦੀਆਂ Shannon Coder ਕਾਲਾਂ ਵਰਤੀਆਂ ਜਾ ਚੁੱਕੀਆਂ ਹਨ।
500 server_error The model backend failed to answer. Please retry. ਮਾਡਲ ਨੇ ਜਵਾਬ ਨਹੀਂ ਬਣਾਇਆ। ਰਿਕੁਐਸਟ ਦੁਬਾਰਾ ਭੇਜੋ।
502 api_error The model backend failed to answer. Please retry. ਮਾਡਲ ਨੇ ਜਵਾਬ ਨਹੀਂ ਬਣਾਇਆ। ਰਿਕੁਐਸਟ ਦੁਬਾਰਾ ਭੇਜੋ।

ਟੋਕਨਾਂ ਦੀ ਗਿਣਤੀ

POST /v1/messages/count_tokens ਇੱਕ message ਰਿਕੁਐਸਟ ਵਾਲੀ ਹੀ body ਲੈਂਦਾ ਹੈ (model, system, messages, tools) ਅਤੇ {"input_tokens": n} ਮੋੜਦਾ ਹੈ: ਯਾਨੀ ਇਨਪੁਟ ਟੋਕਨਾਂ ਦੀ ਗਿਣਤੀ ਜਿੰਨੀ ਇਸ ਰਿਕੁਐਸਟ ਉੱਤੇ ਲਗਾਈ ਜਾਵੇਗੀ। ਇਹ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਲਈ ਗਿਣਦਾ ਹੈ, ਮੁਫ਼ਤ ਹੈ ਅਤੇ ਫਲੱਡ ਪ੍ਰੋਟੈਕਸ਼ਨ ਵਿੱਚ ਨਹੀਂ ਗਿਣਿਆ ਜਾਂਦਾ।

import anthropic

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

count = client.messages.count_tokens(
    model="DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    system="You are a physics teacher. Answer in two sentences.",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
)

print(count.input_tokens)

ਗਿਣਤੀ ਦਾ ਆਪਣਾ ਪੰਨਾ ਹੈ, ਜਿਸ ਵਿੱਚ plain-text endpoint ਅਤੇ ਸੀਮਾਵਾਂ ਹਨ। ਟੋਕਨ ਗਿਣਤੀ