सामग्रीमा जानुहोस्
Anthropic ढाँचा

Anthropic ढाँचा

POST /v1/messages ले Anthropic Messages ढाँचामा अनुरोध लिन्छ र स्ट्रिम गरिएको होस् वा नहोस्, उही ढाँचामा जवाफ दिन्छ। यसलाई Anthropic SDK र त्यसमा आधारित Claude Code जस्ता टुलहरूसँग प्रयोग गर्नुहोस्: बेस URL सेट गर्नुहोस्, आफ्नो Shannon API की प्रयोग गर्नुहोस् र एउटा Shannon मोडल id को नाम दिनुहोस्।

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

Anthropic SDK लाई Shannon बेस URL तर्फ देखाउनुहोस्। SDK ले /v1/messages थप्छ र तपाईंको की 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)

जवाफ एउटा सन्देश हो जसको content ब्लकहरूको सूची हो। ब्लकहरूलाई तिनको type बाट भेट्टाउनुहोस्: मोडलले रिजनिङ गरेको छ भने पहिलो ब्लक 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
  }
}

हेडरहरू

हेडर मान विवरण
x-api-key YOUR_API_KEY तपाईंको API की। यसको सट्टा 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 हुन्छ।

अनुरोध फिल्डहरू

केवल messages आवश्यक छ। लागू गर्ने स्तम्भले फिल्डले जवाफ बदल्ने मोडलहरूको नाम दिन्छ। होस्ट गरिएका ओपन-वेट मोडलहरू मोडल सूचीका बाह्र id हुन्; Shannon 3 परिवार shannon-3, shannon-3-pro, shannon-3.1 र shannon-3.1-pro हो। मोडल र मूल्य

फिल्ड प्रकार पूर्वनिर्धारित विवरण लागू गर्ने
model string shannon-1.6-lite मोडल सूचीबाट एउटा Shannon मोडल id। हरेक अनुरोधसँग पठाउनुहोस्। मिलान केस-सेन्सिटिभ हुँदैन। अरू कुनै पनि नामले 400 unknown model फर्काउँछ, त्यसैले आफ्नै मोडल नाम पठाउने टुललाई Shannon id मा सेट गर्नुपर्छ। सबै मोडल
messages array आवश्यक। कुराकानी, सबैभन्दा पुरानो सन्देश पहिले, user र assistant भूमिकासहित। तल Messages र कन्टेन्ट ब्लकहरू हेर्नुहोस्। सबै मोडल
system string | array मोडलका लागि निर्देशनहरू: स्ट्रिङ वा टेक्स्ट ब्लकहरूको एरे। तल सिस्टम प्रम्प्ट हेर्नुहोस्। होस्ट गरिएका ओपन-वेट मोडलहरू, shannon-1.6-*, shannon-2-*, shannon-coder-1
max_tokens integer 4096 जवाफको माथिल्लो सीमा, टोकनमा। यो इन्डपोइन्टमा ऐच्छिक; Anthropic SDK ले सधैं पठाउँछ। 1 देखि 65,536 बाहिरको मानलाई त्यो दायरामा सारिन्छ। अनुरोध चलिरहँदा तपाईंको ब्यालेन्सबाट छुट्याइएको रकम पनि यही हो। होस्ट गरिएका ओपन-वेट मोडलहरू, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1
stream boolean false true ले जवाफलाई सर्भर-सेन्ट इभेन्टका रूपमा पठाउँछ। तल स्ट्रिमिङ हेर्नुहोस्। सबै मोडल
temperature number स्याम्पलिङ तापक्रम। होस्ट गरिएका ओपन-वेट मोडलहरूमा मान 0 र 2 बीच राखिन्छन्। होस्ट गरिएका ओपन-वेट मोडलहरू, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1
top_p number न्युक्लियस स्याम्पलिङ। होस्ट गरिएका ओपन-वेट मोडलहरू
stop_sequences array 4 वटासम्म स्ट्रिङ। जवाफ देखिने पहिलो स्ट्रिङ अगाडि नै सकिन्छ। stop_reason end_turn नै रहन्छ। होस्ट गरिएका ओपन-वेट मोडलहरू
tools array मोडलले कल गर्न सक्ने टुलहरू, प्रत्येक {"name", "description", "input_schema"} को रूपमा। तल टुलहरू हेर्नुहोस्। सबै मोडल
tool_choice object {"type": "auto"} ले मोडललाई निर्णय गर्न दिन्छ, {"type": "any"} ले यसलाई टुल कल गर्न लगाउँछ, {"type": "tool", "name": "…"} ले यसलाई त्यही टुल कल गर्न लगाउँछ। होस्ट गरिएका ओपन-वेट मोडलहरू
thinking object उत्तर दिनु अघि मोडलले कति रिजनिङ गर्छ। तल थिंकिङ हेर्नुहोस्। होस्ट गरिएका ओपन-वेट मोडलहरू
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 मार्करहरू स्वीकार गरिन्छन् ताकि अवस्थित क्लाइन्ट कोड परिवर्तन बिना चलोस्। तिनले जवाफ बदल्दैनन्; होस्ट गरिएका ओपन-वेट मोडलहरूमा प्रम्प्ट क्याशिङ स्वचालित हुन्छ।

स्कीमा अनुसारको JSON जवाफ Chat Completions मा response_format ले र Responses मा text.format ले माग गरिन्छ। संरचित आउटपुट

सिस्टम प्रम्प्ट र थिंकिङसहितको अनुरोध

यो अनुरोधले सिस्टम प्रम्प्ट, थिंकिङ बजेट, तापक्रम र एउटा स्टप सिक्वेन्स पठाउँछ। यसले होस्ट गरिएको ओपन-वेट मोडल प्रयोग गर्छ, जसले ती सबै लागू गर्छ।

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)

होस्ट गरिएका ओपन-वेट मोडलहरूमा usage ले प्रम्प्ट क्याशबाट पढिएका टोकनहरूलाई अन्य इनपुट टोकनहरूभन्दा छुट्टै रिपोर्ट गर्छ।

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

सिस्टम प्रम्प्ट

system स्ट्रिङ हो, वा [{"type": "text", "text": "…"}] रूपमा टेक्स्ट ब्लकहरूको एरे। ब्लकहरूका टेक्स्टहरू नयाँ लाइनले जोडिन्छन्।

यसलाई होस्ट गरिएका ओपन-वेट मोडलहरू, shannon-1.6-lite, shannon-1.6-pro, shannon-2-lite, shannon-2-pro र shannon-coder-1 ले लागू गर्छन्। Shannon 3 परिवारको id सँग, अनिवार्य रूपमा पालना हुनुपर्ने निर्देशनहरू प्रयोगकर्ता सन्देशमा राख्नुहोस्।

Messages र कन्टेन्ट ब्लकहरू

सन्देशमा role, user वा assistant, र एउटा content हुन्छ। content स्ट्रिङ वा ब्लकहरूको एरे हुन्छ।

ब्लक विवरण उपलब्ध
{"type": "text", "text": "…"} टेक्स्ट। सबै मोडल
{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": "…"}}
{"type": "image", "source": {"type": "url", "url": "…"}}
user सन्देशमा एउटा छवि, base64 वा URL को रूपमा। Shannon 3 परिवार, shannon-1.6-lite, shannon-1.6-pro, र छवि इनपुट सूचीबद्ध गर्ने होस्ट गरिएका ओपन-वेट मोडलहरू
{"type": "document", "source": {"type": "base64", "media_type": "application/pdf", "data": "…"}} user सन्देशमा एउटा कागजात (PDF, Word, PowerPoint वा Excel), base64 वा URL को रूपमा। Shannon 3 परिवार
{"type": "tool_use", "id": "toolu_…", "name": "…", "input": {…}} assistant सन्देशमा: मोडलले अघिल्लो जवाफमा गरेको टुल कल। सबै मोडल
{"type": "tool_result", "tool_use_id": "toolu_…", "content": "…"} user सन्देशमा: उक्त कलको नतिजा। content स्ट्रिङ वा टेक्स्ट ब्लकहरूको सूची हुन्छ। सबै मोडल

तपाईं अघिल्लो जवाफको content जस्ताको तस्तै फिर्ता पठाउन सक्नुहुन्छ: text र tool_use ब्लकहरू पढिन्छन्, thinking ब्लकहरू छोडिन्छन्।

Shannon तहहरूमा छवि र कागजातहरू अन्तिम user सन्देशबाट पढिन्छन्। आकार र सीमाको आफ्नै पेज छ। छवि र फाइलहरू

थिंकिङ

होस्ट गरिएका ओपन-वेट मोडलहरूले thinking लाई रिजनिङ एफर्टमा नक्सा गर्छन्। फिल्ड नभए एफर्ट उच्च हुन्छ।

रूप budget_tokens प्रभाव
{"type": "disabled"} रिजनिङ छैन। जवाफमा thinking ब्लक हुँदैन।
{"type": "enabled", "budget_tokens": 2048} ≤ 2,048 न्यून एफर्ट।
{"type": "enabled", "budget_tokens": 8192} ≤ 8,192 मध्यम एफर्ट।
{"type": "enabled", "budget_tokens": 16000} > 8,192 उच्च एफर्ट।

रिजनिङ गर्ने मोडलले आफ्नो रिजनिङ टेक्स्ट अघि {"type": "thinking", "thinking": "…"} ब्लकका रूपमा फर्काउँछ। रिजनिङ गर्ने Shannon तहहरूले पनि यसलाई पठाउँछन्।

एफर्टहरूको वर्णन तिनका आफ्नै पेजमा छ। रिजनिङ एफर्ट

टुलहरू

टुल भनेको तपाईंको कोडले चलाउने फङ्सन हो। हरेकलाई name, description र input_schema ले वर्णन गर्नुहोस्। मोडललाई टुल चाहिँदा जवाफमा tool_use ब्लक हुन्छ र 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"
    }
  }
]

टुल चलाउनुहोस्, त्यसपछि कल र tool_result ब्लक messages मा थपेर अनुरोध फेरि पठाउनुहोस्:

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"} मोडलले एउटा टुल अनिवार्य कल गर्नुपर्छ। होस्ट गरिएका ओपन-वेट मोडलहरू
{"type": "tool", "name": "…"} मोडलले नाम दिइएको टुल अनिवार्य कल गर्नुपर्छ। होस्ट गरिएका ओपन-वेट मोडलहरू

input_schema भएका टुलहरू मात्र पढिन्छन्। वेब खोज यो इन्डपोइन्टमा टुल होइन: web_search फिल्ड सेट गर्नुहोस्।

टुल लुपको पूर्ण वर्णन यसको आफ्नै पेजमा छ। फङ्क्शन कलिङ

जवाफ

फिल्ड प्रकार विवरण पठाउने
id string msg_ पछि 32 हेक्साडेसिमल अक्षर। सबै मोडल
type string सधैं message। सबै मोडल
role string सधैं assistant। सबै मोडल
model string उत्तर दिने मोडलको क्यानोनिकल id। सबै मोडल
content array जवाफका ब्लकहरू, यही क्रममा: मोडलले रिजनिङ गरेको भए thinking, text, त्यसपछि हरेक टुल कलका लागि एउटा 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 हुन्छ। होस्ट गरिएका ओपन-वेट मोडलहरू

जवाफका ब्लकहरू

ब्लक विवरण
{"type": "thinking", "thinking": "…"} मोडलको रिजनिङ। यसमा signature सदस्य हुँदैन।
{"type": "text", "text": "…"} उत्तरको टेक्स्ट। जवाफ टुल कल हुँदा यो खाली हुन सक्छ।
{"type": "tool_use", "id": "toolu_…", "name": "…", "input": {…}} एउटा टुल कल। input JSON अब्जेक्ट हो। नतिजा उही id सहित फिर्ता पठाउनुहोस्।

stop_reason

stop_reason विवरण पठाउने
end_turn मोडलले आफ्नो उत्तर पूरा गर्‍यो, वा तपाईंको stop_sequences मध्ये एउटा देखियो। सबै मोडल
tool_use जवाफमा एक वा बढी टुल कल छन्। सबै मोडल
max_tokens जवाफ आउटपुट सीमामा काटियो। Shannon 3 परिवार, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1, स्ट्रिमहरूमा

स्ट्रिमिङ

सर्भर-सेन्ट इभेन्टका लागि stream लाई true सेट गर्नुहोस्। हरेक फ्रेममा इभेन्टको नाम भएको event: लाइन र type मा त्यही नाम दोहोर्‍याउने JSON अब्जेक्ट भएको data: लाइन हुन्छ। Anthropic SDK का स्ट्रिम हेल्परहरूले यी इभेन्टहरू तपाईंका लागि पढ्छन्:

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)

इभेन्टहरू, आइपुग्ने क्रममा:

इभेन्ट डेटा कहिले
message_start message सधैं पहिलो। message मा id, भूमिका, मोडल, खाली content र शून्यबाट सुरु हुने usage हुन्छ।
content_block_start index, content_block एउटा ब्लक खुल्छ। content_block खाली text वा thinking ब्लक हो, वा यसको id र name सहितको tool_use ब्लक।
content_block_delta index, delta {"type": "thinking_delta", "thinking"} thinking ब्लकका लागि, रिजनिङको एक टुक्रा।
content_block_delta index, delta {"type": "text_delta", "text"} text ब्लकका लागि, उत्तरको एक टुक्रा।
content_block_delta index, delta {"type": "input_json_delta", "partial_json"} tool_use ब्लकका लागि, टुल कलका आर्ग्युमेन्टहरू, एउटै डेल्टामा पूर्ण रूपमा।
content_block_stop index यो index भएको ब्लक पूरा भयो।
message_delta delta {stop_reason, stop_sequence}, usage जवाफको अन्त्य: delta.stop_reason, र अनुरोधको usage।
message_stop सधैं अन्तिम।

ब्लकहरू खुल्ने क्रममा index द्वारा नम्बर गरिन्छन्, र अर्को ब्लक खुल्नु अघि एउटा ब्लक पूरा हुन्छ। हरेक ब्लकलाई यसको नम्बरले होइन, प्रकारले पढ्नुहोस्: स्ट्रिमले पहिले खाली text ब्लक खोल्न सक्छ, त्यसपछि thinking ब्लक, र उत्तर पछिल्लो text ब्लकमा पठाउन सक्छ।

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

कीप-अलाइभ

पठाउने विवरण
Shannon 3 परिवार, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1 {"type": "ping"} डेटा भएको ping इभेन्ट, हरेक 15 सेकेन्डमा।
होस्ट गरिएका ओपन-वेट मोडलहरू कमेन्ट लाइन : keepalive, मोडलले काम गरिरहँदा हरेक 15 सेकेन्डमा।

असफल हुने स्ट्रिम

स्ट्रिम सुरु भएपछिको विफलता त्रुटि जवाफकै बडी भएको error इभेन्ट हो: {"type": "error", "error": {"type", "message"}}। समापन इभेन्टहरू, message_delta र message_stop, तैपनि पछि आउँछन्। जवाफलाई असफल मान्नुहोस् र अनुरोध फेरि पठाउनुहोस्।

त्रुटिहरू

त्रुटिहरूले Anthropic त्रुटि बडी प्रयोग गर्छन्: type error हुन्छ, र error अब्जेक्टमा type र message हुन्छ। तालिकाले यो इन्डपोइन्टले प्रायः फर्काउने कुराहरू सूचीबद्ध गर्छ। के पुनः प्रयास गर्ने भन्ने सहितको पूर्ण सूचीको आफ्नै पेज छ। त्रुटि व्यवस्थापन

400 JSON
{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "unknown model: no-such-model"
  }
}
स्थिति प्रकार सन्देश कहिले
401 authentication_error Missing authentication
Invalid API key
कुनै API की पठाइएन, वा की अज्ञात वा रद्द गरिएको छ।
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 छवि इनपुट नभएको होस्ट गरिएको ओपन-वेट मोडलमा छवि पठाइयो।
422 invalid_request_error Failed to deserialize the JSON body into the target type: … messages हराइरहेको छ, वा कुनै फिल्डको 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 ले सन्देश अनुरोधकै बडी (model, system, messages, tools) लिन्छ र {"input_tokens": n} फर्काउँछ: अनुरोधलाई शुल्क लाग्ने इनपुट टोकनको संख्या। यसले होस्ट गरिएका ओपन-वेट मोडलहरूका लागि गणना गर्छ, यो निःशुल्क छ र फ्लड प्रोटेक्सनले यसलाई गनिँदैन।

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)

गणनाको आफ्नै पेज छ, जसमा प्लेन-टेक्स्ट इन्डपोइन्ट र सीमाहरू छन्। टोकन गणना