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) 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."}]
}' ਜਵਾਬ ਇੱਕ message ਹੈ ਜਿਸ ਦਾ content blocks ਦੀ ਸੂਚੀ ਹੈ। Blocks ਨੂੰ ਉਨ੍ਹਾਂ ਦੇ type ਤੋਂ ਲੱਭੋ: ਜਦੋਂ ਮਾਡਲ ਨੇ ਰੀਜ਼ਨਿੰਗ ਕੀਤੀ ਹੋਵੇ, ਪਹਿਲਾ 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 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) 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?"}]
}' ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ usage ਪ੍ਰੋਂਪਟ ਕੈਸ਼ ਤੋਂ ਪੜ੍ਹੇ ਟੋਕਨਾਂ ਨੂੰ ਬਾਕੀ ਇਨਪੁਟ ਟੋਕਨਾਂ ਤੋਂ ਅਲੱਗ ਦੱਸਦਾ ਹੈ।
{
"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 ਵਿੱਚ ਇੱਕ ਟੂਲ ਪਰਿਭਾਸ਼ਾ:
[
{
"name": "get_weather",
"description": "Current weather for a city.",
"input_schema": {
"type": "object",
"properties": {
"city": {
"type": "string"
}
},
"required": [
"city"
]
}
}
] ਉਸ ਨੂੰ ਕਾਲ ਕਰਨ ਵਾਲੇ ਜਵਾਬ ਦਾ content:
[
{
"type": "text",
"text": ""
},
{
"type": "tool_use",
"id": "toolu_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
"name": "get_weather",
"input": {
"city": "Paris"
}
}
] ਟੂਲ ਚਲਾਓ, ਫਿਰ ਰਿਕੁਐਸਟ ਦੁਬਾਰਾ ਭੇਜੋ, ਜਿਸ ਵਿੱਚ 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"} | ਮਾਡਲ ਆਪ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਟੂਲ ਕਾਲ ਕਰਨਾ ਹੈ ਜਾਂ ਨਹੀਂ। ਇਹ ਡਿਫਾਲਟ ਹੈ। | ਸਾਰੇ ਮਾਡਲ |
{"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) 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, ਮਾਡਲ, ਖਾਲੀ 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 ਵਿੱਚ ਦੇ ਸਕਦੀ ਹੈ।
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 ਸਭ ਤੋਂ ਵੱਧ ਮੋੜਦਾ ਹੈ। ਪੂਰੀ ਸੂਚੀ, ਇਸ ਸਮੇਤ ਕਿ ਕਿਸ ਨੂੰ ਦੁਬਾਰਾ ਅਜ਼ਮਾਉਣਾ ਹੈ, ਦਾ ਆਪਣਾ ਪੰਨਾ ਹੈ। ਗਲਤੀਆਂ
{
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "unknown model: no-such-model"
}
} | ਸਟੇਟਸ | ਕਿਸਮ | Message | ਕਦੋਂ |
|---|---|---|---|
401 | authentication_error | Missing authenticationInvalid 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) 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 ਅਤੇ ਸੀਮਾਵਾਂ ਹਨ। ਟੋਕਨ ਗਿਣਤੀ