விரைவு தொடக்கம்

முதல் கோரிக்கையைச் செய்யுங்கள்: உங்கள் key-ஐப் பெற்று, ஒரு செய்தியை அனுப்பி, பதிலைப் படியுங்கள். API OpenAI மற்றும் Anthropic வடிவங்களில் பேசுகிறது, எனவே நீங்கள் ஏற்கனவே பயன்படுத்தும் SDK-யின் base URL-ஐயும் key-ஐயும் மாற்றிய பிறகு அது வேலை செய்யும்.

1. உங்கள் key-ஐப் பெறுங்கள்

ஒவ்வொரு கணக்குக்கும் ஒரு API key உண்டு. உள்நுழைந்து, Keys & usage-ஐத் திறந்து அதை நகலெடுங்கள். key ஒவ்வொரு endpoint-லும் ஒவ்வொரு மாடலிலும் வேலை செய்யும். Keys & usage

2. உங்கள் கிளையன்ட்டை API-க்குச் சுட்டுங்கள்

அனைத்து endpoint-களும் ஒரே 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`

மூன்று endpoint-கள் உரையை உருவாக்குகின்றன. அவை ஒரே மாடல்களை அடைகின்றன; உங்கள் குறியீடு ஏற்கனவே பயன்படுத்தும் வடிவத்துக்கு உரியதைத் தேர்ந்தெடுங்கள்.

எண்ட்பாயிண்ட்	வடிவம்
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. முதல் கோரிக்கையை அனுப்புங்கள்

Chat Completions endpoint-ல் shannon-3-க்கு ஒரு user செய்தியை அனுப்புங்கள். 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. id-கள் மாடல்கள் & விலை பக்கத்தில் பட்டியலிடப்பட்டுள்ளன.
`messages`	`array`		இதுவரையிலான உரையாடல்: `role` மற்றும் `content` கொண்ட objects. கடைசி `user` செய்தியே prompt. கட்டாயம்.
`max_tokens`	`integer`	`4096`	கோரிக்கையின் வெளியீட்டு அளவு, 1 முதல் 65,536 வரை. கோரிக்கை இந்த அளவை உங்கள் இருப்பிலிருந்து ஒதுக்கி, உண்மையில் பயன்படுத்தியதற்குக் கட்டணம் செலுத்தும்.
`stream`	`boolean`	`false`	`true` பதிலை எழுதப்படும்போதே துண்டு துண்டாக அனுப்பும்.

கோரிக்கை body JSON ஆகும், Content-Type: application/json header தேவை. புலங்களின் முழுப் பட்டியல் 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`	பதிலுக்கு முன் மாடலின் reasoning, எதுவும் இல்லையென்றால் `null`.
`choices[0].message.tool_calls`	`array`	நீங்கள் அறிவித்த tools-ல் ஒன்றை மாடல் அழைக்கும்போது மட்டுமே இருக்கும்.
`choices[0].finish_reason`	`string`	பதிலுக்கு `stop`, மாடல் tool-ஐ அழைக்கும்போது `tool_calls`.
`usage.prompt_tokens`	`integer`	இந்தப் பதிலுக்காக மாடல் படித்த டோக்கன்கள். `shannon-2-*` மற்றும் Shannon 3 குடும்பத்தில் இது நீங்கள் அனுப்பிய உரையை விட அதிகமாக இருக்கலாம்.
`usage.completion_tokens`	`integer`	மாடல் எழுதிய டோக்கன்கள்.
`usage.total_tokens`	`integer`	மொத்தம். Shannon மாடலின் கட்டணம் இந்த எண்ணிலிருந்து கணக்கிடப்படுகிறது.

usage டோக்கன் எண்ணிக்கைகளைக் கொண்டிருக்கும், பணத்தை அல்ல. அழைப்பு உங்கள் இருப்பிலிருந்து எவ்வளவு எடுத்தது என்பது Keys & usage-ல் ஒவ்வொரு கோரிக்கைக்கும் காட்டப்படும்; அது எவ்வாறு கணக்கிடப்படுகிறது என்பது வரம்புகளும் இருப்பும் பக்கத்தில் உள்ளது. வரம்புகளும் இருப்பும்
பிழை மற்றும் stream உட்பட ஒவ்வொரு பதிலிலும் x-request-id header உண்டு. உங்கள் கோரிக்கையில் x-request-id header இருந்தால், அதன் மதிப்பு திரும்பி வரும்; இல்லையென்றால் மதிப்பு 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
மாடல் reasoning செய்யும்போது. பூஜ்யம் அல்லது அதற்கு மேற்பட்ட 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 திறந்த பிறகு ஏற்படும் தோல்வி data: {"error": {…}} frame ஆக வந்து சேரும். நிலை 200 ஆகவே இருக்கும், எனவே frames-ஐச் சரிபாருங்கள்.

ஸ்ட்ரீமிங்

அழைப்பு தோல்வியடைந்தால்

பிழை என்பது type மற்றும் message கொண்ட error உடைய JSON object. முதல் அழைப்பு அடிக்கடி சந்திக்கும் பதில்கள் இவை.

நிலை	வகை	செய்தி	அதன் பொருள்
`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`	கோரிக்கையின் வெளியீட்டு அளவு உங்கள் இருப்புக்குள் பொருந்தவில்லை.

கையாளுவதில் பிழை

அடுத்து எங்கே செல்வது

மாடல்கள் & விலை — ஒரு மாடலைத் தேர்ந்தெடுங்கள்: id-கள், context window-கள் மற்றும் விலைகள்.
Chat Completions — நீங்கள் அழைத்த endpoint-ன் ஒவ்வொரு கோரிக்கைப் புலம், பதில் புலம் மற்றும் stream நிகழ்வு.
ஸ்ட்ரீமிங் — stream-ன் frames, keep-alive வரிகள் மற்றும் stream-க்குள் வரும் பிழைகள்.
செயல்பாடு அழைப்பு — மாடல் உங்கள் செயல்பாடுகளை அழைக்கட்டும்.
வரம்புகளும் இருப்பும் — ஒரு கோரிக்கை எதை ஒதுக்குகிறது, எவ்வளவு செலவாகிறது, எத்தனை கோரிக்கைகள் அனுப்பலாம்.
API விளையாட்டு மைதானம் — உங்கள் key-யுடன் உலாவியில் கோரிக்கைகளை முயற்சிக்கவும்.