త్వరిత ప్రారంభం
మొదటి రిక్వెస్ట్ చేయండి: మీ కీని పొందండి, ఒక మెసేజ్ పంపండి మరియు సమాధానం చదవండి. API OpenAI మరియు Anthropic ఫార్మాట్లను మాట్లాడుతుంది, కాబట్టి మీరు ఇప్పటికే వాడే SDK దాని బేస్ URL మరియు కీని మార్చిన తర్వాత పనిచేస్తుంది.
1. మీ కీని పొందండి
ప్రతి ఖాతాకు ఒక API కీ ఉంటుంది. సైన్ ఇన్ చేసి, Keys & usage ను తెరిచి దాన్ని కాపీ చేయండి. కీ ప్రతి ఎండ్పాయింట్లో మరియు ప్రతి మోడల్లో పనిచేస్తుంది. 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 | సమాధానం ఇచ్చే మోడల్ యొక్క id. ids 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 | సమాధానం ఇచ్చిన మోడల్ యొక్క ప్రచురించిన id, మీరు alias లేదా మరో స్పెల్లింగ్ పంపినప్పుడు కూడా. |
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 మోడల్ ఛార్జ్ ఈ సంఖ్య నుండి లెక్కించబడుతుంది. |
-
usagetokens లెక్కలను కలిగి ఉంటుంది, డబ్బును కాదు. కాల్ మీ బ్యాలెన్స్ నుండి ఏమి తీసుకుందో 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 ప్రచురించిన id కాదు. Models & pricing లోని 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 — మీరు కాల్ చేసిన ఎండ్పాయింట్ యొక్క ప్రతి రిక్వెస్ట్ ఫీల్డ్, సమాధాన ఫీల్డ్ మరియు స్ట్రీమ్ ఈవెంట్.
- స్ట్రీమింగ్ — స్ట్రీమ్ ఫ్రేమ్లు, keep-alive లైన్లు మరియు స్ట్రీమ్ లోపల ఎరర్లు.
- ఫంక్షన్ కాలింగ్ — మోడల్ మీ ఫంక్షన్లను కాల్ చేయనివ్వండి.
- పరిమితులు మరియు బ్యాలెన్స్ — రిక్వెస్ట్ ఏమి రిజర్వ్ చేస్తుంది మరియు ఎంత ఖర్చవుతుంది, మరియు మీరు ఎన్ని రిక్వెస్ట్లు పంపవచ్చు.
- API Playground — మీ కీతో బ్రౌజర్లో రిక్వెస్ట్లను ప్రయత్నించండి.