ਤੁਰੰਤ ਸ਼ੁਰੂ

ਪਹਿਲੀ ਰਿਕੁਐਸਟ ਕਰੋ: ਆਪਣੀ key ਲਓ, ਇੱਕ message ਭੇਜੋ ਅਤੇ ਜਵਾਬ ਪੜ੍ਹੋ। API OpenAI ਅਤੇ Anthropic ਫਾਰਮੈਟ ਬੋਲਦੀ ਹੈ, ਇਸ ਲਈ ਜੋ SDK ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਵਰਤਦੇ ਹੋ ਉਹ ਉਸ ਦਾ base URL ਅਤੇ key ਬਦਲਣ ਤੋਂ ਬਾਅਦ ਕੰਮ ਕਰਦਾ ਹੈ।

1. ਆਪਣੀ key ਲਓ

ਹਰ ਖਾਤੇ ਕੋਲ ਇੱਕ API key ਹੁੰਦੀ ਹੈ। ਸਾਈਨ ਇਨ ਕਰੋ, Keys & usage ਖੋਲ੍ਹੋ ਅਤੇ ਇਸ ਨੂੰ ਕਾਪੀ ਕਰੋ। key ਹਰ endpoint ਅਤੇ ਹਰ ਮਾਡਲ ਉੱਤੇ ਕੰਮ ਕਰਦੀ ਹੈ। Keys ਅਤੇ ਵਰਤੋਂ

2. ਆਪਣੇ ਕਲਾਇੰਟ ਨੂੰ API ਵੱਲ ਕਰੋ

ਸਾਰੇ endpoints ਇੱਕ base URL ਹੇਠ ਹਨ। OpenAI SDK ਇਸ ਨੂੰ ਅੰਤ ਵਿੱਚ /v1 ਸਮੇਤ ਲੈਂਦਾ ਹੈ; Anthropic SDK ਇਸ ਤੋਂ ਬਿਨਾਂ ਲੈਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਉਹ /v1/messages ਆਪ ਜੋੜਦਾ ਹੈ।

ਕਲਾਇੰਟ	Base URL
OpenAI SDK ਅਤੇ OpenAI-ਅਨੁਕੂਲ ਕਲਾਇੰਟ	`https://api.shannon-ai.com/v1`
Anthropic SDK	`https://api.shannon-ai.com`

ਤਿੰਨ endpoints ਟੈਕਸਟ ਪੈਦਾ ਕਰਦੇ ਹਨ। ਉਹ ਇੱਕੋ ਮਾਡਲਾਂ ਤੱਕ ਪਹੁੰਚਦੇ ਹਨ; ਉਹ ਚੁਣੋ ਜਿਸ ਦਾ ਫਾਰਮੈਟ ਤੁਹਾਡਾ ਕੋਡ ਪਹਿਲਾਂ ਹੀ ਵਰਤਦਾ ਹੈ।

ਐਂਡਪੁਆਇੰਟ	ਫਾਰਮੈਟ
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. ਪਹਿਲੀ ਰਿਕੁਐਸਟ ਭੇਜੋ

Chat Completions endpoint ਉੱਤੇ shannon-3 ਨੂੰ ਇੱਕ user message ਭੇਜੋ। YOUR_API_KEY ਨੂੰ ਆਪਣੀ key ਨਾਲ ਬਦਲੋ।

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="shannon-3",
    messages=[
        {"role": "user", "content": "Hello, Shannon!"}
    ],
    max_tokens=1024
)

print(response.choices[0].message.content)

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: 'shannon-3',
  messages: [
    { role: 'user', content: 'Hello, Shannon!' }
  ],
  max_tokens: 1024
});

console.log(response.choices[0].message.content);

package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("YOUR_API_KEY")
    config.BaseURL = "https://api.shannon-ai.com/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "shannon-3",
            Messages: []openai.ChatCompletionMessage{
                {Role: "user", Content: "Hello, Shannon!"},
            },
            MaxTokens: 1024,
        },
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

curl -X POST "https://api.shannon-ai.com/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "shannon-3",
    "messages": [
      {"role": "user", "content": "Hello, Shannon!"}
    ],
    "max_tokens": 1024
  }'

ਫੀਲਡ	ਕਿਸਮ	ਡਿਫੌਲਟ	ਵੇਰਵਾ
`model`	`string`		ਜਵਾਬ ਦੇਣ ਵਾਲੇ ਮਾਡਲ ਦੀ id। ids ਮਾਡਲ ਅਤੇ ਕੀਮਤ ਪੰਨੇ ਉੱਤੇ ਸੂਚੀਬੱਧ ਹਨ।
`messages`	`array`		ਹੁਣ ਤੱਕ ਦੀ ਗੱਲਬਾਤ: `role` ਅਤੇ `content` ਵਾਲੇ objects। ਆਖਰੀ `user` message ਪ੍ਰੋਂਪਟ ਹੈ। ਲਾਜ਼ਮੀ।
`max_tokens`	`integer`	`4096`	ਰਿਕੁਐਸਟ ਦਾ ਆਉਟਪੁੱਟ ਬਜਟ, 1 ਤੋਂ 65,536 ਤੱਕ। ਰਿਕੁਐਸਟ ਇਹ ਰਕਮ ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਵਿੱਚੋਂ ਰਿਜ਼ਰਵ ਕਰਦੀ ਹੈ ਅਤੇ ਜੋ ਸੱਚਮੁੱਚ ਵਰਤਿਆ ਉਸ ਦਾ ਚਾਰਜ ਲੱਗਦਾ ਹੈ।
`stream`	`boolean`	`false`	`true` ਜਵਾਬ ਨੂੰ ਲਿਖੇ ਜਾਣ ਦੌਰਾਨ ਟੁਕੜਾ-ਟੁਕੜਾ ਭੇਜਦਾ ਹੈ।

ਰਿਕੁਐਸਟ body JSON ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਹੈਡਰ Content-Type: application/json ਚਾਹੀਦਾ ਹੈ। ਫੀਲਡਾਂ ਦੀ ਪੂਰੀ ਸੂਚੀ endpoint ਪੰਨੇ ਉੱਤੇ ਹੈ। Chat Completions

ਜਵਾਬ

stream ਤੋਂ ਬਿਨਾਂ ਕਾਲ ਜਵਾਬ ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਇੱਕ JSON object ਵਾਪਸ ਕਰਦੀ ਹੈ। ਹੇਠਾਂ ਦੇ ਟੈਕਸਟ ਅਤੇ ਸੰਖਿਆਵਾਂ ਉਦਾਹਰਣਾਂ ਹਨ।

200 JSON

{
  "id": "chatcmpl-9b2f6c1e4a7d4f0f8a3c5d2e1b6a7c90",
  "object": "chat.completion",
  "created": 1791590400,
  "model": "shannon-3",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! What would you like to work on?",
        "reasoning_content": "A greeting. A short, friendly reply fits."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1386,
    "completion_tokens": 74,
    "total_tokens": 1460
  }
}

ਫੀਲਡ	ਕਿਸਮ	ਵੇਰਵਾ
`id`	`string`	`chatcmpl-` ਤੋਂ ਬਾਅਦ 32 ਹੈਕਸਾਡੈਸੀਮਲ ਅੱਖਰ।
`object`	`string`	ਹਮੇਸ਼ਾ `chat.completion`।
`created`	`integer`	ਜਵਾਬ ਦਾ ਸਮਾਂ, Unix ਸਕਿੰਟਾਂ ਵਿੱਚ।
`model`	`string`	ਜਵਾਬ ਦੇਣ ਵਾਲੇ ਮਾਡਲ ਦੀ ਪ੍ਰਕਾਸ਼ਿਤ id, ਉਦੋਂ ਵੀ ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਉਪ-ਨਾਂ ਜਾਂ ਹੋਰ ਸਪੈਲਿੰਗ ਭੇਜੀ ਹੋਵੇ।
`choices`	`array`	ਹਮੇਸ਼ਾ ਇੱਕ ਐਂਟਰੀ, `index` 0 ਨਾਲ।
`choices[0].message.role`	`string`	ਹਮੇਸ਼ਾ `assistant`।
`choices[0].message.content`	`string \| null`	ਜਵਾਬ। ਜਦੋਂ ਜਵਾਬ ਵਿੱਚ `tool_calls` ਹੋਣ ਤਾਂ ਇਹ `null` ਹੋ ਸਕਦਾ ਹੈ।
`choices[0].message.reasoning_content`	`string \| null`	ਜਵਾਬ ਤੋਂ ਪਹਿਲਾਂ ਮਾਡਲ ਦੀ ਰੀਜ਼ਨਿੰਗ, ਜਾਂ ਕੁਝ ਨਾ ਹੋਣ ਉੱਤੇ `null`।
`choices[0].message.tool_calls`	`array`	ਸਿਰਫ਼ ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਮਾਡਲ ਤੁਹਾਡੇ ਐਲਾਨ ਕੀਤੇ ਟੂਲਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ।
`choices[0].finish_reason`	`string`	ਜਵਾਬ ਲਈ `stop`, ਅਤੇ ਜਦੋਂ ਮਾਡਲ ਟੂਲ ਕਾਲ ਕਰਦਾ ਹੈ ਤਾਂ `tool_calls`।
`usage.prompt_tokens`	`integer`	ਉਹ tokens ਜੋ ਮਾਡਲ ਨੇ ਇਸ ਜਵਾਬ ਲਈ ਪੜ੍ਹੇ। `shannon-2-*` ਅਤੇ Shannon 3 ਪਰਿਵਾਰ ਉੱਤੇ ਇਹ ਉਸ ਟੈਕਸਟ ਤੋਂ ਵੱਧ ਹੋ ਸਕਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਭੇਜਿਆ।
`usage.completion_tokens`	`integer`	ਉਹ tokens ਜੋ ਮਾਡਲ ਨੇ ਲਿਖੇ।
`usage.total_tokens`	`integer`	ਕੁੱਲ। Shannon ਮਾਡਲ ਦਾ ਚਾਰਜ ਇਸੇ ਸੰਖਿਆ ਤੋਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।

usage ਵਿੱਚ token ਗਿਣਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਪੈਸੇ ਨਹੀਂ। ਕਾਲ ਨੇ ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਵਿੱਚੋਂ ਕੀ ਲਿਆ, ਇਹ Keys & usage ਉੱਤੇ ਹਰ ਰਿਕੁਐਸਟ ਲਈ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ; ਇਹ ਕਿਵੇਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ ਇਹ ਸੀਮਾਵਾਂ ਅਤੇ ਬੈਲੇਂਸ ਪੰਨੇ ਉੱਤੇ ਹੈ। ਸੀਮਾਵਾਂ ਅਤੇ ਬੈਲੇਂਸ
ਹਰ ਜਵਾਬ, ਗਲਤੀ ਅਤੇ stream ਸਮੇਤ, ਵਿੱਚ ਹੈਡਰ x-request-id ਹੁੰਦਾ ਹੈ। ਜੇ ਤੁਹਾਡੀ ਰਿਕੁਐਸਟ ਵਿੱਚ x-request-id ਹੈਡਰ ਹੋਵੇ ਤਾਂ ਉਸ ਦਾ ਮੁੱਲ ਵਾਪਸ ਆਉਂਦਾ ਹੈ; ਨਹੀਂ ਤਾਂ ਮੁੱਲ 12 ਹੈਕਸਾਡੈਸੀਮਲ ਅੱਖਰ ਹੁੰਦਾ ਹੈ। ਇਸ ਨੂੰ ਆਪਣੇ ਲੌਗਾਂ ਵਿੱਚ ਰੱਖੋ: ਇਹ ਇਸ ਇੱਕ ਰਿਕੁਐਸਟ ਦਾ ਨਾਂ ਹੈ।

ਉਹੀ ਕਾਲ stream ਵਜੋਂ

ਜਵਾਬ ਨੂੰ ਲਿਖੇ ਜਾਣ ਦੌਰਾਨ ਪੜ੍ਹਨ ਲਈ stream ਨੂੰ true ਕਰੋ। ਰਿਕੁਐਸਟ ਵਿੱਚ ਬਾਕੀ ਸਭ ਕੁਝ ਉਹੀ ਰਹਿੰਦਾ ਹੈ।

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="shannon-3",
    messages=[
        {"role": "user", "content": "Hello, Shannon!"}
    ],
    max_tokens=1024,
    stream=True
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

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: 'shannon-3',
  messages: [
    { role: 'user', content: 'Hello, Shannon!' }
  ],
  max_tokens: 1024,
  stream: true
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

curl -N -X POST "https://api.shannon-ai.com/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "shannon-3",
    "messages": [
      {"role": "user", "content": "Hello, Shannon!"}
    ],
    "max_tokens": 1024,
    "stream": true
  }'

stream ਦਾ ਹਰ frame data: ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੀ ਇੱਕ ਲਾਈਨ ਹੈ ਜਿਸ ਵਿੱਚ JSON object ਹੁੰਦਾ ਹੈ। ਇੱਕ frame, ਕਈ ਲਾਈਨਾਂ ਵਿੱਚ ਛਾਪਿਆ ਹੋਇਆ:

ਇੱਕ frame

{
  "id": "chatcmpl-9b2f6c1e4a7d4f0f8a3c5d2e1b6a7c90",
  "object": "chat.completion.chunk",
  "created": 1791590400,
  "model": "shannon-3",
  "choices": [
    {
      "index": 0,
      "delta": {
        "content": "Hello! "
      },
      "finish_reason": null
    }
  ]
}

Frames, ਕ੍ਰਮ ਅਨੁਸਾਰ	delta	finish_reason
ਜਦੋਂ ਮਾਡਲ ਰੀਜ਼ਨਿੰਗ ਕਰਦਾ ਹੈ। ਜ਼ੀਰੋ ਜਾਂ ਵੱਧ frames।	`{"reasoning_content": "…"}`	`null`
ਜਵਾਬ, ਟੁਕੜਾ-ਟੁਕੜਾ। ਜ਼ੀਰੋ ਜਾਂ ਵੱਧ frames।	`{"content": "…"}`	`null`
ਆਖਰੀ JSON frame। ਇਸ ਵਿੱਚ `usage` ਵੀ ਹੁੰਦੀ ਹੈ; ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਮੰਗਣ ਦੀ ਲੋੜ ਨਹੀਂ।	`{}`	`"stop"`
stream ਦਾ ਅੰਤ: ਲਾਈਨ `data: [DONE]`।

ਜਵਾਬ ਦਾ ਸਟੇਟਸ 200 ਅਤੇ content-type: text/event-stream ਹੈ। ਹਰ frame ਇੱਕ ਲਾਈਨ data: <json> ਹੈ ਜਿਸ ਤੋਂ ਬਾਅਦ ਇੱਕ ਖਾਲੀ ਲਾਈਨ ਆਉਂਦੀ ਹੈ।
ਲਾਈਨ : ping ਹਰ 15 ਸਕਿੰਟ ਬਾਅਦ ਪਹੁੰਚਦੀ ਹੈ। ਇਹ ਇੱਕ ਟਿੱਪਣੀ ਹੈ ਜੋ ਕਨੈਕਸ਼ਨ ਨੂੰ ਖੁੱਲ੍ਹਾ ਰੱਖਦੀ ਹੈ; SSE ਕਲਾਇੰਟ ਇਸ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹਨ।
stream ਖੁੱਲ੍ਹਣ ਤੋਂ ਬਾਅਦ ਆਈ ਅਸਫਲਤਾ ਇੱਕ frame data: {"error": {…}} ਵਜੋਂ ਪਹੁੰਚਦੀ ਹੈ। ਸਟੇਟਸ 200 ਹੀ ਰਹਿੰਦਾ ਹੈ, ਇਸ ਲਈ frames ਦੀ ਜਾਂਚ ਕਰੋ।

ਸਟ੍ਰੀਮਿੰਗ

ਜੇ ਕਾਲ ਅਸਫਲ ਹੋ ਜਾਵੇ

ਗਲਤੀ ਇੱਕ JSON object ਹੈ ਜਿਸ ਦੇ error ਵਿੱਚ type ਅਤੇ message ਹੁੰਦੇ ਹਨ। ਇਹ ਉਹ ਜਵਾਬ ਹਨ ਜੋ ਪਹਿਲੀ ਕਾਲ ਨੂੰ ਸਭ ਤੋਂ ਵੱਧ ਮਿਲਦੇ ਹਨ।

ਸਟੇਟਸ	ਕਿਸਮ	ਸੁਨੇਹਾ	ਇਸ ਦਾ ਕੀ ਮਤਲਬ ਹੈ
`401`	`authentication_error`	`Missing authentication`	ਕੋਈ key API ਤੱਕ ਨਹੀਂ ਪਹੁੰਚੀ। `Authorization: Bearer` ਅਤੇ ਉਸ ਤੋਂ ਬਾਅਦ ਆਪਣੀ key ਭੇਜੋ।
`401`	`authentication_error`	`Invalid API key`	key ਕਿਸੇ ਖਾਤੇ ਦੀ ਮੌਜੂਦਾ key ਨਹੀਂ ਹੈ। ਇਸ ਨੂੰ Keys & usage ਤੋਂ ਦੁਬਾਰਾ ਕਾਪੀ ਕਰੋ।
`400`	`invalid_request_error`	`unknown model: <id>`	`model` ਕੋਈ ਪ੍ਰਕਾਸ਼ਿਤ id ਨਹੀਂ ਹੈ। ਮਾਡਲ ਅਤੇ ਕੀਮਤ ਪੰਨੇ ਤੋਂ ਕੋਈ id ਵਰਤੋ।
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	ਕਿਸੇ ਫੀਲਡ ਦੀ JSON ਕਿਸਮ ਗਲਤ ਹੈ, ਜਾਂ `messages` ਗੈਰਹਾਜ਼ਰ ਹੈ।
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	ਰਿਕੁਐਸਟ ਦਾ ਆਉਟਪੁੱਟ ਬਜਟ ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਵਿੱਚ ਨਹੀਂ ਸਮਾਉਂਦਾ।

ਗਲਤੀਆਂ

ਅੱਗੇ ਕਿੱਥੇ ਜਾਣਾ ਹੈ

ਮਾਡਲ ਅਤੇ ਕੀਮਤਾਂ — ਮਾਡਲ ਚੁਣੋ: ids, ਕਾਂਟੈਕਸਟ ਵਿੰਡੋਆਂ ਅਤੇ ਕੀਮਤਾਂ।
Chat Completions — ਜਿਸ endpoint ਨੂੰ ਤੁਸੀਂ ਕਾਲ ਕੀਤਾ ਉਸ ਦਾ ਹਰ ਰਿਕੁਐਸਟ ਫੀਲਡ, ਜਵਾਬ ਫੀਲਡ ਅਤੇ stream event।
ਸਟ੍ਰੀਮਿੰਗ — stream ਦੇ frames, keep-alive ਲਾਈਨਾਂ ਅਤੇ stream ਦੇ ਅੰਦਰ ਦੀਆਂ ਗਲਤੀਆਂ।
ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ — ਮਾਡਲ ਨੂੰ ਆਪਣੇ ਫੰਕਸ਼ਨ ਕਾਲ ਕਰਨ ਦਿਓ।
ਸੀਮਾਵਾਂ ਅਤੇ ਬੈਲੇਂਸ — ਰਿਕੁਐਸਟ ਕੀ ਰਿਜ਼ਰਵ ਕਰਦੀ ਹੈ ਅਤੇ ਉਸ ਦੀ ਕੀ ਲਾਗਤ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਕਿੰਨੀਆਂ ਰਿਕੁਐਸਟਾਂ ਭੇਜ ਸਕਦੇ ਹੋ।
API ਪਲੇਗਰਾਊਂਡ — ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਆਪਣੀ key ਨਾਲ ਰਿਕੁਐਸਟਾਂ ਅਜ਼ਮਾਓ।