Fillim i shpejtë

Bëni një kërkesë të parë: merrni çelësin, dërgoni një mesazh dhe lexoni përgjigjen. API-ja flet format OpenAI dhe Anthropic, prandaj SDK-ja që përdorni tashmë funksionon pasi të ndryshoni URL-në bazë dhe çelësin.

1. Merrni çelësin tuaj

Çdo llogari ka një çelës API. Hyni, hapni Çelësat dhe përdorimi dhe kopjojeni. Çelësi funksionon në çdo endpoint dhe çdo model. Çelësat dhe përdorimi

2. Drejtojeni klientin te API-ja

Të gjitha endpoint-et ndodhen nën një URL bazë. Një SDK OpenAI e merr me /v1 në fund; një SDK Anthropic e merr pa të, sepse e shton vetë /v1/messages.

Klienti	URL bazë
SDK-të OpenAI dhe klientët e pajtueshëm me OpenAI	`https://api.shannon-ai.com/v1`
SDK-të Anthropic	`https://api.shannon-ai.com`

Tri endpoint-e prodhojnë tekst. Arrijnë të njëjtat modele; zgjidhni atë, formatin e të cilit e përdor tashmë kodi juaj.

Endpoint	Formati
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Dërgoni një kërkesë të parë

Dërgoni një mesazh user te shannon-3 në endpoint-in Chat Completions. Zëvendësoni YOUR_API_KEY me çelësin tuaj.

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

Fusha	Lloji	Parazgjedhja	Përshkrimi
`model`	`string`		Id-ja e modelit që përgjigjet. Id-të listohen te Modelet dhe çmimet.
`messages`	`array`		Biseda deri tani: objekte me `role` dhe `content`. Mesazhi i fundit `user` është prompt-i. I detyrueshëm.
`max_tokens`	`integer`	`4096`	Buxheti i daljes së kërkesës, nga 1 deri 65,536. Kërkesa e rezervon këtë sasi nga bilanci juaj dhe faturohet për atë që përdori realisht.
`stream`	`boolean`	`false`	`true` e dërgon përgjigjen copë-copë ndërsa shkruhet.

Trupi i kërkesës është JSON dhe ka nevojë për header-in Content-Type: application/json. Lista e plotë e fushave është te faqja e endpoint-it. Chat Completions

Përgjigjja

Një thirrje pa stream kthen një objekt JSON kur përgjigjja është e plotë. Tekstet dhe numrat më poshtë janë shembuj.

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

Fusha	Lloji	Përshkrimi
`id`	`string`	`chatcmpl-` e ndjekur nga 32 karaktere heksadecimale.
`object`	`string`	Gjithmonë `chat.completion`.
`created`	`integer`	Koha e përgjigjes në sekonda Unix.
`model`	`string`	Id-ja e publikuar e modelit që u përgjigj, edhe kur dërguat një alias ose shkrim tjetër.
`choices`	`array`	Gjithmonë një hyrje, me `index` 0.
`choices[0].message.role`	`string`	Gjithmonë `assistant`.
`choices[0].message.content`	`string \| null`	Përgjigjja. Mund të jetë `null` kur përgjigjja mban `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Arsyetimi i modelit para përgjigjes, ose `null` kur nuk ka.
`choices[0].message.tool_calls`	`array`	I pranishëm vetëm kur modeli thërret një nga mjetet që deklaruat.
`choices[0].finish_reason`	`string`	`stop` për një përgjigje, `tool_calls` kur modeli thërret një mjet.
`usage.prompt_tokens`	`integer`	Tokens-at që modeli lexoi për këtë përgjigje. Te `shannon-2-*` dhe familja Shannon 3 kjo mund të jetë më shumë se teksti që dërguat.
`usage.completion_tokens`	`integer`	Tokens-at që shkroi modeli.
`usage.total_tokens`	`integer`	Totali. Faturimi i një modeli Shannon llogaritet nga ky numër.

usage mban numërime tokens-ash, jo para. Ajo që thirrja mori nga bilanci juaj tregohet për kërkesë te Çelësat dhe përdorimi; si llogaritet është te Kufijtë dhe bilanci. Kufijtë dhe bilanci
Çdo përgjigje, edhe gabim dhe stream, ka header-in x-request-id. Nëse kërkesa juaj mban një header x-request-id, vlera e tij kthehet; përndryshe vlera është 12 karaktere heksadecimale. Mbajeni në regjistrat tuaj: emërton këtë kërkesë të vetme.

E njëjta thirrje si stream

Vendosni stream në true për ta lexuar përgjigjen ndërsa shkruhet. Gjithçka tjetër në kërkesë mbetet e njëjtë.

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

Çdo frame i stream-it është një rresht që fillon me data: dhe mban një objekt JSON. Një frame, i printuar në disa rreshta:

Një frame

{
  "id": "chatcmpl-9b2f6c1e4a7d4f0f8a3c5d2e1b6a7c90",
  "object": "chat.completion.chunk",
  "created": 1791590400,
  "model": "shannon-3",
  "choices": [
    {
      "index": 0,
      "delta": {
        "content": "Hello! "
      },
      "finish_reason": null
    }
  ]
}

Frame-et, në radhë	delta	finish_reason
Ndërsa modeli arsyeton. Zero ose më shumë frame.	`{"reasoning_content": "…"}`	`null`
Përgjigjja, copë-copë. Zero ose më shumë frame.	`{"content": "…"}`	`null`
Frame-i i fundit JSON. Mban edhe `usage`; nuk keni nevojë ta kërkoni.	`{}`	`"stop"`
Fundi i stream-it: rreshti `data: [DONE]`.

Përgjigjja ka statusin 200 dhe content-type: text/event-stream. Çdo frame është një rresht data: <json> i ndjekur nga një rresht bosh.
Një rresht : ping arrin çdo 15 sekonda. Është një koment që e mban lidhjen të hapur; klientët SSE e kapërcejnë.
Një dështim pasi stream-i është hapur arrin si frame data: {"error": {…}}. Statusi mbetet 200, prandaj kontrolloni frame-et.

Transmetim

Nëse thirrja dështon

Një gabim është një objekt JSON me një error që mban type dhe message. Këto janë përgjigjet që has më shpesh një thirrje e parë.

Statusi	Lloji	Mesazhi	Çfarë do të thotë
`401`	`authentication_error`	`Missing authentication`	Asnjë çelës nuk arriti te API-ja. Dërgoni `Authorization: Bearer` e ndjekur nga çelësi juaj.
`401`	`authentication_error`	`Invalid API key`	Çelësi nuk është çelësi aktual i një llogarie. Kopjojeni përsëri nga Çelësat dhe përdorimi.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` nuk është id e publikuar. Përdorni një id nga Modelet dhe çmimet.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Një fushë ka lloj JSON të gabuar, ose `messages` mungon.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Buxheti i daljes së kërkesës nuk ngjit në bilancin tuaj.

Trajtimi i gabimeve

Ku të shkoni më tej

Modelet dhe çmimet — Zgjidhni një model: id, dritare konteksti dhe çmime.
Chat Completions — Çdo fushë kërkese, fushë përgjigjeje dhe ngjarje stream-i e endpoint-it që thirrët.
Transmetim — Frame-et e një stream-i, rreshtat keep-alive dhe gabimet brenda një stream-i.
Thirrje funksionesh — Lëreni modelin të thërrasë funksionet tuaja.
Kufijtë dhe bilanci — Çfarë rezervon dhe çfarë kushton një kërkesë, dhe sa kërkesa mund të dërgoni.
API Playground — Provoni kërkesa në shfletues me çelësin tuaj.