Anthropic
POST /v1/messages Anthropic Messages ආකෘතියේ ඉල්ලීමක් ගෙන එම ආකෘතියෙන්ම පිළිතුරු දෙයි, stream කළ හෝ නොකළ. එය Anthropic SDK සමඟද Claude Code වැනි එය මත ගොඩනැගූ tools සමඟද භාවිතා කරන්න: base URL එක සකසන්න, ඔබේ Shannon API යතුර භාවිතා කරන්න සහ Shannon model id එකක් නම් කරන්න.
POST https://api.shannon-ai.com/v1/messages
Anthropic SDK එක Shannon base URL එකට යොමු කරන්න. SDK එක /v1/messages එකතු කර ඔබේ key එක x-api-key header එකෙන් යවයි.
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) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const message = await client.messages.create({
model: "shannon-3",
max_tokens: 1024,
messages: [{ role: "user", content: "Say hello in one sentence." }],
});
for (const block of message.content) {
if (block.type === "text") console.log(block.text);
} curl https://api.shannon-ai.com/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "content-type: application/json" \
-d '{
"model": "shannon-3",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Say hello in one sentence."}]
}' පිළිතුර යනු content එක blocks ලැයිස්තුවක් වන පණිවිඩයකි. Blocks ඒවායේ type අනුව සොයන්න: model එක තර්ක කළ විට පළමු block එක thinking වන අතර පෙළ එයට පසුව පැමිණේ.
{
"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 යතුර. ඒ වෙනුවට 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 එකක් පිළිතුර වෙනස් කරන models නම් කර ඇත. Host කළ open-weight models යනු model ලැයිස්තුවේ ids දොළොස; Shannon 3 පවුල යනු shannon-3, shannon-3-pro, shannon-3.1 සහ shannon-3.1-pro ය. Models සහ මිල ගණන්
| Field | වර්ගය | පෙරනිමිය | විස්තරය | යොදන්නේ |
|---|---|---|---|---|
model | string | shannon-1.6-lite | Model ලැයිස්තුවෙන් Shannon model id එකක්. එය සෑම ඉල්ලීමක්ම සමඟ යවන්න. ගැලපීම case-sensitive නොවේ. වෙනත් ඕනෑම නමක් 400 unknown model ආපසු දෙයි, එබැවින් තමන්ගේම model නම් යවන tool එකක් Shannon id එකකට සැකසිය යුතුය. | සියලු models |
messages | array | අවශ්යයි. user සහ assistant භූමිකා සහිත සංවාදය, පැරණිම පණිවිඩය මුලින්. පහත Messages සහ content blocks බලන්න. | සියලු models | |
system | string | array | Model එකට උපදෙස්: string එකක් හෝ text blocks වල array එකක්. පහත System prompt බලන්න. | අපගේ සේවාදායකවල ධාවනය වන open-weight models, shannon-1.6-*, shannon-2-*, shannon-coder-1 | |
max_tokens | integer | 4096 | පිළිතුරේ ඉහළ සීමාව, tokens වලින්. මෙම endpoint එකේ අත්යවශ්ය නොවේ; Anthropic SDK එක එය සෑම විටම යවයි. 1 සිට 65,536 දක්වා පරාසයෙන් පිටත අගයක් එම පරාසය තුළට ගෙන එනු ලැබේ. ඉල්ලීම ක්රියාත්මක වන අතරතුර ඔබේ ශේෂයෙන් වෙන් කර තබන ප්රමාණයද එයයි. | අපගේ සේවාදායකවල ධාවනය වන open-weight models, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1 |
stream | boolean | false | true පිළිතුර server-sent events ලෙස යවයි. පහත Streaming බලන්න. | සියලු models |
temperature | number | Sampling temperature. Host කළ open-weight models මත අගයන් 0 සහ 2 අතර තබා ගනී. | අපගේ සේවාදායකවල ධාවනය වන open-weight models, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1 | |
top_p | number | Nucleus sampling. | අපගේ සේවාදායකවල ධාවනය වන open-weight models | |
stop_sequences | array | Strings 4 ක් දක්වා. පළමුව පෙනෙන එකට පෙර පිළිතුර අවසන් වේ. stop_reason end_turn ලෙසම පවතී. | අපගේ සේවාදායකවල ධාවනය වන open-weight models | |
tools | array | Model එකට call කළ හැකි tools, ඒ සෑම එකක්ම {"name", "description", "input_schema"} ලෙස. පහත Tools බලන්න. | සියලු models | |
tool_choice | object | {"type": "auto"} model එකට තීරණය කිරීමට ඉඩ දෙයි, {"type": "any"} tool එකක් call කිරීමට සලස්වයි, {"type": "tool", "name": "…"} එම tool එක call කිරීමට සලස්වයි. | අපගේ සේවාදායකවල ධාවනය වන open-weight models | |
thinking | object | පිළිතුරු දීමට පෙර model එක කොපමණ reasoning කරන්නේද යන්න. පහත Thinking බලන්න. | අපගේ සේවාදායකවල ධාවනය වන open-weight models | |
web_search | boolean | false | ආකෘතියට Shannon එකතු කිරීමක්: true පිළිතුරු දීමට පෙර model එකට වෙබ් සෙවීමට ඉඩ දෙයි. | shannon-1.6-*, shannon-2-*, Shannon 3 පවුල |
max_tokens නැතිව අගය 4,096 වන අතර shannon-coder-1 හි 65,536 වේ.
දැනට ඇති client කේතය වෙනස් නොකර ක්රියා කිරීමට metadata, top_k, service_tier සහ blocks මත ඇති cache_control සලකුණු පිළිගනී. ඒවා පිළිතුර වෙනස් නොකරයි; host කළ open-weight models මත prompt caching ස්වයංක්රීයයි.
Schema එකකට අනුව JSON පිළිතුරක් Chat Completions හි response_format සමඟද Responses හි text.format සමඟද ඉල්ලයි. ව්යුහගත ප්රතිදාන
System prompt සහ thinking සහිත ඉල්ලීමක්
මෙම ඉල්ලීම system prompt එකක්, thinking budget එකක්, temperature එකක් සහ stop sequence එකක් යවයි. එය ඒ සියල්ල යොදන host කළ open-weight model එකක් භාවිතා කරයි.
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) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const message = await 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 (const block of message.content) {
if (block.type === "thinking") console.log("reasoning:", block.thinking);
if (block.type === "text") console.log("answer:", block.text);
}
console.log(message.usage); curl https://api.shannon-ai.com/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "content-type: application/json" \
-d '{
"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?"}]
}' Host කළ open-weight models මත usage prompt cache එකෙන් කියවූ tokens, අනෙකුත් input tokens වලින් වෙන්ව වාර්තා කරයි.
{
"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 models වන shannon-1.6-lite, shannon-1.6-pro, shannon-2-lite, shannon-2-pro සහ shannon-coder-1 ය. Shannon 3 පවුලේ id එකක් සමඟ, අනිවාර්යයෙන් පිළිපැදිය යුතු උපදෙස් user පණිවිඩයට ඇතුළත් කරන්න.
පණිවිඩ සහ content blocks
පණිවිඩයක role (user හෝ assistant) සහ content ඇත. content යනු string එකක් හෝ blocks වල array එකකි.
| Block | විස්තරය | ලබා ගත හැක්කේ |
|---|---|---|
{"type": "text", "text": "…"} | Text. | සියලු models |
{"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 සහ රූප input ලැයිස්තුගත කරන host කළ open-weight models |
{"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 පණිවිඩයක: model එක පෙර පිළිතුරකදී කළ tool call එකක්. | සියලු models |
{"type": "tool_result", "tool_use_id": "toolu_…", "content": "…"} | user පණිවිඩයක: එම call එකේ ප්රතිඵලය. content යනු string එකක් හෝ text blocks ලැයිස්තුවකි. | සියලු models |
පෙර පිළිතුරක content එය ඇති ආකාරයටම නැවත යැවිය හැක: text සහ tool_use blocks කියවයි, thinking blocks මඟ හරියි.
Shannon මට්ටම් වලදී රූප සහ ලේඛන කියවන්නේ අවසන් user පණිවිඩයෙනි. ප්රමාණ සහ සීමා සඳහා වෙනම පිටුවක් ඇත. රූප සහ ගොනු
Thinking
අපගේ සේවාදායකවල ධාවනය වන open-weight models thinking reasoning effort එකකට සිතියම් කරයි. Field එක නොමැතිව effort එක high වේ.
| ආකාරය | 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. |
තර්ක කරන model එකක් එහි තර්කනය පෙළට පෙර {"type": "thinking", "thinking": "…"} block එකක් ලෙස ආපසු දෙයි. තර්ක කරන Shannon tiers ද එය යවයි.
Efforts ගැන තමන්ගේම පිටුවේ විස්තර කර ඇත. Reasoning effort
Tools
Tool එකක් යනු ඔබේ code එක ක්රියාත්මක කරන function එකකි. ඒ සෑම එකක්ම name, description සහ input_schema සමඟ විස්තර කරන්න. Model එකට tool එකක් අවශ්ය වූ විට, පිළිතුරේ tool_use block එකක් ඇති අතර stop_reason tool_use වේ.
tools හි tool අර්ථ දැක්වීමක්:
[
{
"name": "get_weather",
"description": "Current weather for a city.",
"input_schema": {
"type": "object",
"properties": {
"city": {
"type": "string"
}
},
"required": [
"city"
]
}
}
] එය call කරන පිළිතුරක content:
[
{
"type": "text",
"text": ""
},
{
"type": "tool_use",
"id": "toolu_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
"name": "get_weather",
"input": {
"city": "Paris"
}
}
] Tool එක ක්රියාත්මක කර, ඉන්පසු call එක සහ messages වලට එකතු කළ tool_result block එකක් සමඟ ඉල්ලීම නැවත යවන්න:
[
{
"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"} | Tool එකක් call කරනවාද යන්න model එක තීරණය කරයි. මෙය පෙරනිමියයි. | සියලු models |
{"type": "any"} | Model එක tools වලින් එකක් call කළ යුතුය. | අපගේ සේවාදායකවල ධාවනය වන open-weight models |
{"type": "tool", "name": "…"} | Model එක නම් කළ tool එක call කළ යුතුය. | අපගේ සේවාදායකවල ධාවනය වන open-weight models |
කියවන්නේ input_schema ඇති tools පමණි. මෙම endpoint හි Web search යනු tool එකක් නොවේ: web_search field එක සකසන්න.
Tool loop එක සම්පූර්ණයෙන් තමන්ගේම පිටුවේ විස්තර කර ඇත. කාර්ය කැඳවීම
පිළිතුර
| Field | වර්ගය | විස්තරය | යවන්නේ |
|---|---|---|---|
id | string | msg_ ට පසුව hexadecimal අක්ෂර 32ක්. | සියලු models |
type | string | සෑම විටම message. | සියලු models |
role | string | සෑම විටම assistant. | සියලු models |
model | string | පිළිතුරු දුන් model එකේ canonical id එක. | සියලු models |
content | array | පිළිතුරේ blocks, මෙම අනුපිළිවෙලින්: model එක reasoning කළ විට thinking, text, ඉන්පසු tool call එකකට එක බැගින් tool_use. | සියලු models |
stop_reason | string | පිළිතුර අවසන් වූ හේතුව. පහත අගයන් බලන්න. | සියලු models |
usage | object | input_tokens සහ output_tokens. | සියලු models |
sources | array | web_search: true සහිත, සෙවීමෙන් යමක් සොයාගත් ඉල්ලීමක දී පමණි: model එකට දුන් ප්රතිඵල, සෑම එකකටම index, title සහ url සමඟ. පිළිතුරේ [1] යනු index 1 ඇති ඇතුළත් කිරීමයි. Stream එකකදී එය message_delta event එක සමඟ පැමිණේ. | shannon-1.6-*, shannon-2-*, Shannon 3 පවුල |
usage.cache_read_input_tokens | integer | cache_read_input_tokens යනු cache එකෙන් කියවූ prompt කොටසයි; input_tokens යනු ඉතිරි කොටසයි. cache_creation_input_tokens සෑම විටම 0 වේ. | අපගේ සේවාදායකවල ධාවනය වන open-weight models |
පිළිතුරු blocks
| Block | විස්තරය |
|---|---|
{"type": "thinking", "thinking": "…"} | Model එකේ තර්කනය (reasoning). signature member එකක් නැත. |
{"type": "text", "text": "…"} | පිළිතුරේ text එක. පිළිතුර tool call එකක් වන විට එය හිස් විය හැක. |
{"type": "tool_use", "id": "toolu_…", "name": "…", "input": {…}} | Tool call එකක්. input යනු JSON object එකකි. ප්රතිඵලය එම id සමඟම ආපසු යවන්න. |
stop_reason
| stop_reason | විස්තරය | යවන්නේ |
|---|---|---|
end_turn | Model එක තම පිළිතුර අවසන් කළා, නැතහොත් ඔබේ stop_sequences වලින් එකක් මතු විය. | සියලු models |
tool_use | පිළිතුරේ tool calls එකක් හෝ කිහිපයක් ඇත. | සියලු models |
max_tokens | පිළිතුර output සීමාවේදී කපා හරින ලදී. | Shannon 3 පවුල, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1, streams වල |
Streaming
Server-sent events සඳහා stream true ලෙස සකසන්න. සෑම frame එකකම event එකේ නම සහිත event: පේළියක් සහ type හි එම නම නැවත දක්වන JSON object එකක් සහිත data: පේළියක් ඇත. 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) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const stream = client.messages.stream({
model: "shannon-3",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain server-sent events in three sentences." }],
});
stream.on("text", (text) => process.stdout.write(text));
const message = await stream.finalMessage();
console.log("\n", message.stop_reason, message.usage); curl -N https://api.shannon-ai.com/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "content-type: application/json" \
-d '{
"model": "shannon-3",
"max_tokens": 1024,
"stream": true,
"messages": [{"role": "user", "content": "Explain server-sent events in three sentences."}]
}' Events, ඒවා පැමිණෙන පිළිවෙලට:
| Event | දත්ත | කවදාද |
|---|---|---|
message_start | message | සෑම විටම පළමුව. message හි id, role, model, හිස් 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 එකක් සඳහා, තර්කනයේ (reasoning) කොටසක්. |
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 එකක් සඳහා, tool call එකක arguments, එක delta එකකින් සම්පූර්ණව. |
content_block_stop | index | මෙම index එක සහිත block එක සම්පූර්ණයි. |
message_delta | delta {stop_reason, stop_sequence}, usage | පිළිතුරේ අවසානය: delta.stop_reason, සහ ඉල්ලීමේ usage. |
message_stop | සෑම විටම අවසානයේ. |
Blocks index මගින් ඒවා විවෘත වන පිළිවෙලට අංක කෙරේ, සහ ඊළඟ block එක විවෘත වීමට පෙර එක් block එකක් සම්පූර්ණ වේ. සෑම block එකක්ම එහි අංකයෙන් නොව එහි type එකෙන් කියවන්න: stream එකක් මුලින් හිස් text block එකක් විවෘත කර, ඉන්පසු thinking block එක විවෘත කර, පිළිතුර පසුව එන text block එකකින් ලබා දිය හැක.
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 | {"type": "ping"} දත්ත සහිත ping event එකක්, තත්පර 15කට වරක්. |
| අපගේ සේවාදායකවල ධාවනය වන open-weight models | Model එක වැඩ කරන අතරතුර තත්පර 15කට වරක් : keepalive comment පේළියක්. |
අසාර්ථක වන stream එකක්
Stream එක ආරම්භ වූ පසු සිදුවන අසාර්ථකත්වයක් යනු දෝෂ පිළිතුරක body එකම ඇති error event එකකි: {"type": "error", "error": {"type", "message"}}. අවසන් events වන message_delta සහ message_stop තවමත් ඊට පසුව පැමිණේ. පිළිතුර අසාර්ථක ලෙස සලකා ඉල්ලීම නැවත යවන්න.
දෝෂ
දෝෂ සඳහා Anthropic දෝෂ body එක භාවිතා වේ: type යනු error වන අතර error object එකේ type සහ message ඇත. වගුවේ මෙම endpoint එක බොහෝ විට ආපසු දෙන දේ ලැයිස්තුගත කර ඇත. නැවත උත්සාහ කළ යුතු දේ සමඟ සම්පූර්ණ ලැයිස්තුව වෙනම පිටුවක ඇත. දෝෂ
{
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "unknown model: no-such-model"
}
} | තත්ත්වය | වර්ගය | පණිවිඩය | කවදාද |
|---|---|---|---|
401 | authentication_error | Missing authenticationInvalid API key | API යතුරක් යවා නැත, නැතහොත් යතුර නොදන්නා හෝ අවලංගු කළ එකකි. |
400 | invalid_request_error | unknown model: <id> | model යනු Shannon model id එකක් නොවේ. |
400 | invalid_request_error | No user message provided | Shannon මට්ටම්: ඉල්ලීමේ user text නැත සහ tools නැත. |
400 | invalid_request_error | <id> does not accept image input | රූප input නැති host කළ open-weight model එකකට රූපයක් යවන ලදී. |
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. | Flood protection: ඔබේ ගිණුමෙන් විනාඩියකට ඉල්ලීම් 120 කට වඩා. |
429 | rate_limit_error | Shannon Coder call quota reached. Upgrade your plan at shannon-ai.com/plan | shannon-coder-1: වත්මන් පැය 4 කවුළුව සඳහා ඔබේ සැලසුමේ Shannon Coder calls භාවිතා වී අවසන්. |
500 | server_error | The model backend failed to answer. Please retry. | Model එක පිළිතුරක් නිපදවුවේ නැත. ඉල්ලීම නැවත යවන්න. |
502 | api_error | The model backend failed to answer. Please retry. | Model එක පිළිතුරක් නිපදවුවේ නැත. ඉල්ලීම නැවත යවන්න. |
Tokens ගණන් කිරීම
POST /v1/messages/count_tokens පණිවිඩ ඉල්ලීමක body එකම (model, system, messages, tools) ගෙන {"input_tokens": n} ආපසු දෙයි: ඉල්ලීමට ගාස්තු අය කරන input tokens ගණන. එය host කළ open-weight models සඳහා ගණන් කරයි, එය නොමිලේ වන අතර flood protection මගින් ගණන් නොගනී.
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) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const count = await client.messages.countTokens({
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?" }],
});
console.log(count.input_tokens); curl https://api.shannon-ai.com/v1/messages/count_tokens \
-H "x-api-key: YOUR_API_KEY" \
-H "content-type: application/json" \
-d '{
"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?"}]
}'
# {"input_tokens": 31} ගණන් කිරීමට plain-text endpoint එක සහ සීමා සහිත වෙනම පිටුවක් ඇත. Token ගණන් කිරීම