ចាប់ផ្តើមរហ័ស

ធ្វើ request ដំបូង៖ យក key របស់អ្នក ផ្ញើសារមួយ ហើយអានចម្លើយ។ API និយាយទ្រង់ទ្រាយ OpenAI និង Anthropic ដូច្នេះ SDK ដែលអ្នកប្រើរួចហើយដំណើរការបន្ទាប់ពីអ្នកប្តូរ base URL និង key របស់វា។

1. យក key របស់អ្នក

រាល់គណនីមាន API key មួយ។ សូមចូលគណនី បើក Keys & usage ហើយចម្លងវា។ key ដំណើរការលើគ្រប់ endpoint និងគ្រប់ម៉ូដែល។ Keys & usage

2. ចង្អុល client របស់អ្នកទៅ API

គ្រប់ endpoint ស្ថិតក្រោម base URL មួយ។ OpenAI SDK យកវាជាមួយ /v1 នៅចុង៖ Anthropic SDK យកវាដោយគ្មាន ព្រោះវាបន្ថែម /v1/messages ដោយខ្លួនឯង។

Client	Base URL
OpenAI SDK និង client ដែលត្រូវគ្នានឹង OpenAI	`https://api.shannon-ai.com/v1`
Anthropic SDK	`https://api.shannon-ai.com`

endpoint បីបង្កើតអត្ថបទ។ ពួកវាទៅដល់ម៉ូដែលដូចគ្នា៖ សូមជ្រើសរើសមួយដែលទ្រង់ទ្រាយរបស់វាកូដរបស់អ្នកប្រើរួចហើយ។

Endpoint	ទ្រង់ទ្រាយ
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. ផ្ញើ request ដំបូង

ផ្ញើសារ user មួយទៅ shannon-3 លើ endpoint Chat Completions។ សូមជំនួស 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
  }'

Field	ប្រភេទ	លំនាំដើម	ការពិពណ៌នា
`model`	`string`		id របស់ម៉ូដែលដែលឆ្លើយ។ id ត្រូវបានរាយនៅលើ Models & pricing។
`messages`	`array`		ការសន្ទនាមកទល់ពេលនេះ៖ object ដែលមាន `role` និង `content`។ សារ `user` ចុងក្រោយគឺជា prompt។ ចាំបាច់។
`max_tokens`	`integer`	`4096`	output budget របស់ request ពី 1 ដល់ 65,536។ request បម្រុងចំនួននេះពីសមតុល្យរបស់អ្នក ហើយត្រូវបានគិតថ្លៃសម្រាប់អ្វីដែលវាប្រើពិតប្រាកដ។
`stream`	`boolean`	`false`	`true` ផ្ញើចម្លើយជាបំណែកៗ ខណៈពេលវាត្រូវបានសរសេរ។

ខ្លឹមសារ request គឺជា JSON ហើយត្រូវការ header Content-Type: application/json។ បញ្ជីពេញលេញនៃ field ស្ថិតនៅលើទំព័រ 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
  }
}

Field	ប្រភេទ	ការពិពណ៌នា
`id`	`string`	`chatcmpl-` តាមពីក្រោយដោយតួអក្សរ hexadecimal ចំនួន 32។
`object`	`string`	តែងតែជា `chat.completion`។
`created`	`integer`	ពេលវេលានៃចម្លើយជាវិនាទី Unix។
`model`	`string`	id ដែលបានបោះពុម្ពផ្សាយនៃម៉ូដែលដែលបានឆ្លើយ ទោះអ្នកផ្ញើ alias ឬការសរសេរផ្សេងក៏ដោយ។
`choices`	`array`	តែងតែមានធាតុមួយ ជាមួយ `index` 0។
`choices[0].message.role`	`string`	តែងតែជា `assistant`។
`choices[0].message.content`	`string \| null`	ចម្លើយ។ វាអាចជា `null` នៅពេលចម្លើយមាន `tool_calls`។
`choices[0].message.reasoning_content`	`string \| null`	reasoning របស់ម៉ូដែលមុនចម្លើយរបស់វា ឬ `null` នៅពេលគ្មាន។
`choices[0].message.tool_calls`	`array`	មានតែនៅពេលម៉ូដែលហៅ tool មួយក្នុងចំណោម tool ដែលអ្នកបានប្រកាស។
`choices[0].finish_reason`	`string`	`stop` សម្រាប់ចម្លើយ `tool_calls` នៅពេលម៉ូដែលហៅ tool។
`usage.prompt_tokens`	`integer`	token ដែលម៉ូដែលបានអានសម្រាប់ចម្លើយនេះ។ លើ `shannon-2-*` និងក្រុម Shannon 3 នេះអាចច្រើនជាងអត្ថបទដែលអ្នកបានផ្ញើ។
`usage.completion_tokens`	`integer`	token ដែលម៉ូដែលបានសរសេរ។
`usage.total_tokens`	`integer`	ចំនួនសរុប។ ការគិតថ្លៃរបស់ម៉ូដែល Shannon ត្រូវបានគណនាពីលេខនេះ។

usage មានចំនួន token មិនមែនប្រាក់ទេ។ អ្វីដែលការហៅបានយកពីសមតុល្យរបស់អ្នកត្រូវបានបង្ហាញក្នុងមួយ request នៅ Keys & usage៖ របៀបគណនាវាស្ថិតនៅលើទំព័រដែនកំណត់ និងសមតុល្យ។ ដែនកំណត់ និងសមតុល្យ
រាល់ចម្លើយ រួមទាំង error និង stream មាន header x-request-id។ ប្រសិនបើ request របស់អ្នកមាន header x-request-id តម្លៃរបស់វាត្រឡប់មកវិញ៖ បើមិនដូច្នោះទេ តម្លៃគឺជាតួអក្សរ hexadecimal ចំនួន 12។ សូមរក្សាវាក្នុង log របស់អ្នក៖ វាកំណត់ request តែមួយនេះ។

ការហៅដូចគ្នាជា stream

កំណត់ stream ជា true ដើម្បីអានចម្លើយខណៈពេលវាត្រូវបានសរសេរ។ អ្វីៗផ្សេងទៀតក្នុង request នៅដដែល។

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

រាល់ frame របស់ stream គឺជាបន្ទាត់មួយដែលចាប់ផ្តើមដោយ 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
    }
  ]
}

Frame តាមលំដាប់	delta	finish_reason
ខណៈពេលដែលម៉ូដែលវែកញែក។ សូន្យ ឬច្រើន frame។	`{"reasoning_content": "…"}`	`null`
ចម្លើយ ជាបំណែកៗ។ សូន្យ ឬច្រើន frame។	`{"content": "…"}`	`null`
JSON frame ចុងក្រោយ។ វាក៏មាន `usage` ដែរ៖ អ្នកមិនចាំបាច់សុំវាទេ។	`{}`	`"stop"`
ចុងបញ្ចប់នៃ stream៖ បន្ទាត់ `data: [DONE]`។

ចម្លើយមាន status 200 និង content-type: text/event-stream។ រាល់ frame គឺជាបន្ទាត់ data: <json> តាមពីក្រោយដោយបន្ទាត់ទទេ។
បន្ទាត់ : ping មកដល់រៀងរាល់ 15 វិនាទី។ វាជា comment ដែលរក្សាការតភ្ជាប់ឱ្យបើក៖ SSE client រំលងវា។
ការបរាជ័យបន្ទាប់ពី stream បានបើកមកដល់ជា frame data: {"error": {…}}។ Status នៅតែ 200 ដូច្នេះសូមពិនិត្យ frame។

ស្ទ្រីម

ប្រសិនបើការហៅបរាជ័យ

error គឺជា 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 ពី Models & pricing។
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	field មានប្រភេទ JSON ខុស ឬ `messages` បាត់។
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	output budget របស់ request មិនស្ថិតក្នុងសមតុល្យរបស់អ្នកទេ។

ការគ្រប់គ្រងកំហុស

ទៅទីណាបន្ទាប់

ម៉ូដែល និងតម្លៃ — ជ្រើសរើសម៉ូដែល៖ id, context window និងតម្លៃ។
Chat Completions — រាល់ field នៃ request, field នៃចម្លើយ និង stream event នៃ endpoint ដែលអ្នកបានហៅ។
ស្ទ្រីម — ស៊ុម (frame) នៃ stream, បន្ទាត់ keep-alive និងកំហុសនៅក្នុង stream។
ការហៅមុខងារ — ឱ្យម៉ូដែលហៅ function របស់អ្នក។
ដែនកំណត់ និងសមតុល្យ — អ្វីដែល request បម្រុង និងតម្លៃរបស់វា និងចំនួន request ដែលអ្នកអាចផ្ញើ។
API Playground — សាកល្បង request ក្នុង browser ជាមួយ key របស់អ្នក។