ವೇಗದ ಆರಂಭ
ಮೊದಲ ವಿನಂತಿ ಮಾಡಿ: ನಿಮ್ಮ ಕೀ ಪಡೆಯಿರಿ, ಒಂದು ಸಂದೇಶ ಕಳುಹಿಸಿ ಮತ್ತು ಉತ್ತರ ಓದಿ. 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 | ಉತ್ತರಿಸುವ ಮಾಡೆಲ್ನ id. id ಗಳನ್ನು 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, ನೀವು ಅಲಿಯಾಸ್ ಅಥವಾ ಬೇರೆ ಕಾಗುಣಿತ ಕಳುಹಿಸಿದಾಗಲೂ. |
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 ನಲ್ಲಿ ಪ್ರತಿ ವಿನಂತಿಗೆ ತೋರಿಸಲಾಗುತ್ತದೆ; ಅದನ್ನು ಹೇಗೆ ಲೆಕ್ಕ ಹಾಕಲಾಗುತ್ತದೆ ಎಂಬುದು ಮಿತಿಗಳು ಮತ್ತು ಬ್ಯಾಲೆನ್ಸ್ ಪುಟದಲ್ಲಿದೆ. ಮಿತಿಗಳು ಮತ್ತು ಬ್ಯಾಲೆನ್ಸ್ - ಪ್ರತಿ ಉತ್ತರಕ್ಕೂ, ದೋಷ ಮತ್ತು 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 ನ ಪ್ರತಿ ಫ್ರೇಮ್ 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" |
stream ನ ಅಂತ್ಯ: data: [DONE] ಸಾಲು. |
- ಉತ್ತರಕ್ಕೆ ಸ್ಥಿತಿ
200ಮತ್ತುcontent-type: text/event-streamಇರುತ್ತದೆ. ಪ್ರತಿ ಫ್ರೇಮ್data: <json>ಸಾಲಾಗಿದ್ದು ಅದರ ನಂತರ ಖಾಲಿ ಸಾಲು ಇರುತ್ತದೆ. : pingಸಾಲು ಪ್ರತಿ 15 ಸೆಕೆಂಡ್ಗೆ ಬರುತ್ತದೆ. ಅದು ಸಂಪರ್ಕವನ್ನು ತೆರೆದಿಡುವ ಕಾಮೆಂಟ್; SSE ಕ್ಲೈಂಟ್ಗಳು ಅದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತವೆ.- stream ತೆರೆದ ನಂತರದ ವೈಫಲ್ಯ
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 | ವಿನಂತಿಯ ಔಟ್ಪುಟ್ ಬಜೆಟ್ ನಿಮ್ಮ ಬ್ಯಾಲೆನ್ಸ್ಗೆ ಹೊಂದುವುದಿಲ್ಲ. |
ಮುಂದೆ ಎಲ್ಲಿಗೆ ಹೋಗಬೇಕು
- ಮಾಡೆಲ್ಗಳು ಮತ್ತು ಬೆಲೆ — ಮಾಡೆಲ್ ಆರಿಸಿ: id ಗಳು, ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋಗಳು ಮತ್ತು ಬೆಲೆಗಳು.
- Chat Completions — ನೀವು ಕರೆದ ಎಂಡ್ಪಾಯಿಂಟ್ನ ಪ್ರತಿ ವಿನಂತಿ ಫೀಲ್ಡ್, ಉತ್ತರ ಫೀಲ್ಡ್ ಮತ್ತು stream ಈವೆಂಟ್.
- ಸ್ಟ್ರೀಮಿಂಗ್ — stream ನ ಫ್ರೇಮ್ಗಳು, keep-alive ಸಾಲುಗಳು ಮತ್ತು stream ಒಳಗಿನ ದೋಷಗಳು.
- ಫಂಕ್ಷನ್ ಕಾಲಿಂಗ್ — ಮಾಡೆಲ್ ನಿಮ್ಮ ಫಂಕ್ಷನ್ಗಳನ್ನು ಕರೆಯಲು ಬಿಡಿ.
- ಮಿತಿಗಳು ಮತ್ತು ಬ್ಯಾಲೆನ್ಸ್ — ವಿನಂತಿ ಏನನ್ನು ಮೀಸಲಿಡುತ್ತದೆ ಮತ್ತು ಎಷ್ಟು ವೆಚ್ಚವಾಗುತ್ತದೆ, ಹಾಗೂ ನೀವು ಎಷ್ಟು ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಬಹುದು.
- API Playground — ನಿಮ್ಮ ಕೀಯೊಂದಿಗೆ ಬ್ರೌಸರ್ನಲ್ಲಿ ವಿನಂತಿಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ.