വേഗത്തിലാരംഭം
ആദ്യ റിക്വസ്റ്റ് നടത്തുക: നിങ്ങളുടെ കീ നേടുക, ഒരു മെസേജ് അയയ്ക്കുക, മറുപടി വായിക്കുക. API OpenAI, Anthropic ഫോർമാറ്റുകൾ സംസാരിക്കുന്നു, അതിനാൽ നിങ്ങൾ ഇതിനകം ഉപയോഗിക്കുന്ന SDK അതിന്റെ ബേസ് URL-ഉം കീയും മാറ്റിയാൽ പ്രവർത്തിക്കും.
1. നിങ്ങളുടെ കീ നേടുക
ഓരോ അക്കൗണ്ടിനും ഒരു API കീ ഉണ്ട്. സൈൻ ഇൻ ചെയ്ത് Keys & usage തുറന്ന് അത് കോപ്പി ചെയ്യുക. കീ എല്ലാ എൻഡ്പോയിന്റിലും എല്ലാ മോഡലിലും പ്രവർത്തിക്കും. കീകളും ഉപയോഗവും
2. നിങ്ങളുടെ ക്ലയന്റ് API-യിലേക്ക് ചൂണ്ടുക
എല്ലാ എൻഡ്പോയിന്റുകളും ഒരു ബേസ് URL-ന് കീഴിലാണ്. OpenAI SDK അത് അവസാനം /v1 സഹിതം സ്വീകരിക്കുന്നു; Anthropic SDK അത് ഇല്ലാതെ സ്വീകരിക്കുന്നു, കാരണം അത് /v1/messages സ്വയം ചേർക്കുന്നു.
| ക്ലയന്റ് | ബേസ് URL |
|---|---|
| OpenAI SDK-കളും OpenAI-അനുയോജ്യ ക്ലയന്റുകളും | https://api.shannon-ai.com/v1 |
| Anthropic SDK-കൾ | https://api.shannon-ai.com |
മൂന്ന് എൻഡ്പോയിന്റുകൾ ടെക്സ്റ്റ് ഉണ്ടാക്കുന്നു. അവ ഒരേ മോഡലുകളിൽ എത്തുന്നു; നിങ്ങളുടെ കോഡ് ഇതിനകം ഉപയോഗിക്കുന്ന ഫോർമാറ്റുള്ളത് തിരഞ്ഞെടുക്കുക.
| എൻഡ്പോയിന്റ് | ഫോർമാറ്റ് |
|---|---|
POST /v1/chat/completions | OpenAI Chat Completions |
POST /v1/messages | Anthropic Messages |
POST /v1/responses | OpenAI Responses |
3. ആദ്യ റിക്വസ്റ്റ് അയയ്ക്കുക
Chat Completions എൻഡ്പോയിന്റിൽ shannon-3-ലേക്ക് ഒരു user മെസേജ് അയയ്ക്കുക. YOUR_API_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 | ഉത്തരം നൽകുന്ന മോഡലിന്റെ ഐഡി. ഐഡികൾ Models & pricing-ൽ ലിസ്റ്റ് ചെയ്തിട്ടുണ്ട്. | |
messages | array | ഇതുവരെയുള്ള സംഭാഷണം: role-ഉം content-ഉം ഉള്ള ഒബ്ജക്റ്റുകൾ. അവസാനത്തെ user മെസേജ് ആണ് പ്രോംപ്റ്റ്. നിർബന്ധം. | |
max_tokens | integer | 4096 | റിക്വസ്റ്റിന്റെ ഔട്ട്പുട്ട് ബജറ്റ്, 1 മുതൽ 65,536 വരെ. റിക്വസ്റ്റ് ഈ തുക നിങ്ങളുടെ ബാലൻസിൽ നിന്ന് റിസർവ് ചെയ്യുകയും യഥാർത്ഥത്തിൽ ഉപയോഗിച്ചതിന് ചാർജ് ചെയ്യപ്പെടുകയും ചെയ്യുന്നു. |
stream | boolean | false | true ആയാൽ ഉത്തരം എഴുതപ്പെടുന്നതിനൊപ്പം ഭാഗം ഭാഗമായി അയയ്ക്കും. |
റിക്വസ്റ്റ് ബോഡി JSON ആണ്, Content-Type: application/json ഹെഡർ ആവശ്യമാണ്. ഫീൽഡുകളുടെ പൂർണ്ണ ലിസ്റ്റ് എൻഡ്പോയിന്റ് പേജിലുണ്ട്. Chat Completions
മറുപടി
stream ഇല്ലാത്ത കോൾ ഉത്തരം പൂർത്തിയാകുമ്പോൾ ഒരു 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 | ഉത്തരം നൽകിയ മോഡലിന്റെ പ്രസിദ്ധീകരിച്ച ഐഡി, നിങ്ങൾ ഒരു അപരനാമമോ മറ്റൊരു രൂപമോ അയച്ചാലും. |
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 | ഈ ഉത്തരത്തിനായി മോഡൽ വായിച്ച ടോക്കണുകൾ. shannon-2-*-ലും Shannon 3 കുടുംബത്തിലും ഇത് നിങ്ങൾ അയച്ച ടെക്സ്റ്റിനേക്കാൾ കൂടുതലാകാം. |
usage.completion_tokens | integer | മോഡൽ എഴുതിയ ടോക്കണുകൾ. |
usage.total_tokens | integer | ആകെ തുക. Shannon മോഡലിന്റെ ചാർജ് ഈ സംഖ്യയിൽ നിന്നാണ് കണക്കാക്കുന്നത്. |
-
usage-ൽ ടോക്കൺ എണ്ണങ്ങളാണ് ഉള്ളത്, പണമല്ല. കോൾ നിങ്ങളുടെ ബാലൻസിൽ നിന്ന് എത്ര എടുത്തു എന്നത് Keys & usage-ൽ ഓരോ റിക്വസ്റ്റിനും കാണിക്കുന്നു; അത് എങ്ങനെ കണക്കാക്കുന്നു എന്നത് പരിധികളും ബാലൻസും പേജിലുണ്ട്. പരിധികളും ബാലൻസും - ഓരോ മറുപടിയിലും, പിശകിലും സ്ട്രീമിലും പോലും,
x-request-idഹെഡർ ഉണ്ട്. നിങ്ങളുടെ റിക്വസ്റ്റിൽx-request-idഹെഡർ ഉണ്ടെങ്കിൽ അതിന്റെ മൂല്യം തിരികെ വരും; അല്ലെങ്കിൽ മൂല്യം 12 ഹെക്സാഡെസിമൽ അക്ഷരങ്ങളായിരിക്കും. ഇത് നിങ്ങളുടെ ലോഗുകളിൽ സൂക്ഷിക്കുക: ഇത് ഈ ഒരൊറ്റ റിക്വസ്റ്റിനെ തിരിച്ചറിയുന്നു.
ഇതേ കോൾ ഒരു സ്ട്രീമായി
ഉത്തരം എഴുതപ്പെടുമ്പോൾ തന്നെ വായിക്കാൻ 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
}' സ്ട്രീമിലെ ഓരോ ഫ്രെയിമും data: എന്ന് തുടങ്ങുന്നതും ഒരു JSON ഒബ്ജക്റ്റ് ഉള്ളതുമായ ഒരു വരിയാണ്. ഒരു ഫ്രെയിം, പല വരികളായി അച്ചടിച്ചത്:
{
"id": "chatcmpl-9b2f6c1e4a7d4f0f8a3c5d2e1b6a7c90",
"object": "chat.completion.chunk",
"created": 1791590400,
"model": "shannon-3",
"choices": [
{
"index": 0,
"delta": {
"content": "Hello! "
},
"finish_reason": null
}
]
} | ഫ്രെയിമുകൾ, ക്രമത്തിൽ | delta | finish_reason |
|---|---|---|
| മോഡൽ റീസൺ ചെയ്യുമ്പോൾ. പൂജ്യമോ അതിലധികമോ ഫ്രെയിമുകൾ. | {"reasoning_content": "…"} | null |
| ഉത്തരം, ഭാഗം ഭാഗമായി. പൂജ്യമോ അതിലധികമോ ഫ്രെയിമുകൾ. | {"content": "…"} | null |
അവസാനത്തെ JSON ഫ്രെയിം. ഇതിൽ usage-ഉം ഉണ്ട്; ഇത് ആവശ്യപ്പെടേണ്ടതില്ല. | {} | "stop" |
സ്ട്രീമിന്റെ അവസാനം: data: [DONE] എന്ന വരി. |
- മറുപടിക്ക് സ്റ്റാറ്റസ്
200-ഉംcontent-type: text/event-stream-ഉം ഉണ്ട്. ഓരോ ഫ്രെയിമുംdata: <json>എന്ന വരിയും തുടർന്ന് ഒരു ശൂന്യ വരിയുമാണ്. : pingഎന്ന വരി ഓരോ 15 സെക്കൻഡിലും എത്തുന്നു. ഇത് കണക്ഷൻ തുറന്നുവയ്ക്കുന്ന ഒരു കമന്റാണ്; SSE ക്ലയന്റുകൾ ഇത് ഒഴിവാക്കും.- സ്ട്രീം തുറന്നതിന് ശേഷമുള്ള പരാജയം
data: {"error": {…}}എന്ന ഫ്രെയിമായി എത്തുന്നു. സ്റ്റാറ്റസ്200ആയി തുടരും, അതിനാൽ ഫ്രെയിമുകൾ പരിശോധിക്കുക.
കോൾ പരാജയപ്പെട്ടാൽ
type-ഉം message-ഉം ഉള്ള error അടങ്ങിയ JSON ഒബ്ജക്റ്റ് ആണ് പിശക്. ആദ്യ കോൾ ഏറ്റവും കൂടുതൽ നേരിടുന്ന മറുപടികൾ ഇവയാണ്.
| സ്റ്റാറ്റസ് | ടൈപ്പ് | സന്ദേശം | അർത്ഥം |
|---|---|---|---|
401 | authentication_error | Missing authentication | ഒരു കീയും API-യിൽ എത്തിയില്ല. Authorization: Bearer എന്നതിന് ശേഷം നിങ്ങളുടെ കീ അയയ്ക്കുക. |
401 | authentication_error | Invalid API key | കീ ഒരു അക്കൗണ്ടിന്റെ നിലവിലെ കീ അല്ല. Keys & usage-ൽ നിന്ന് വീണ്ടും കോപ്പി ചെയ്യുക. |
400 | invalid_request_error | unknown model: <id> | model പ്രസിദ്ധീകരിച്ച ഐഡി അല്ല. Models & pricing-ൽ നിന്നുള്ള ഒരു ഐഡി ഉപയോഗിക്കുക. |
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 | റിക്വസ്റ്റിന്റെ ഔട്ട്പുട്ട് ബജറ്റ് നിങ്ങളുടെ ബാലൻസിൽ ഒതുങ്ങുന്നില്ല. |
അടുത്തത് എവിടെ പോകണം
- മോഡലുകളും വിലയും — ഒരു മോഡൽ തിരഞ്ഞെടുക്കുക: ഐഡികൾ, കോൺടെക്സ്റ്റ് വിൻഡോകൾ, വിലകൾ.
- Chat Completions — നിങ്ങൾ വിളിച്ച എൻഡ്പോയിന്റിന്റെ എല്ലാ റിക്വസ്റ്റ് ഫീൽഡുകളും, മറുപടി ഫീൽഡുകളും, സ്ട്രീം ഇവന്റുകളും.
- സ്റ്റ്രീമിംഗ് — സ്ട്രീമിന്റെ ഫ്രെയിമുകൾ, കീപ്-എലൈവ് വരികൾ, സ്ട്രീമിനുള്ളിലെ പിശകുകൾ.
- ഫംഗ്ഷൻ കോളിംഗ് — മോഡലിനെ നിങ്ങളുടെ ഫംഗ്ഷനുകൾ വിളിക്കാൻ അനുവദിക്കുക.
- പരിധികളും ബാലൻസും — ഒരു റിക്വസ്റ്റ് എന്ത് റിസർവ് ചെയ്യുന്നു, എന്ത് ചെലവാകുന്നു, എത്ര റിക്വസ്റ്റുകൾ അയയ്ക്കാം.
- API പ്ലേഗ്രൗണ്ട് — നിങ്ങളുടെ കീ ഉപയോഗിച്ച് ബ്രൗസറിൽ റിക്വസ്റ്റുകൾ പരീക്ഷിക്കുക.