Greita pradžia

Atlikite pirmąją užklausą: gaukite raktą, išsiųskite vieną pranešimą ir perskaitykite atsakymą. API kalba OpenAI ir Anthropic formatais, todėl jau naudojamas SDK veikia pakeitus jo bazinį URL ir raktą.

1. Gaukite raktą

Kiekviena paskyra turi vieną API raktą. Prisijunkite, atidarykite Raktai ir naudojimas ir nukopijuokite jį. Raktas veikia kiekviename galiniame taške ir su kiekvienu modeliu. Raktai ir naudojimas

2. Nukreipkite klientą į API

Visi galiniai taškai yra po vienu baziniu URL. OpenAI SDK jį priima su /v1 gale; Anthropic SDK – be jo, nes pats prideda /v1/messages.

Klientas	Bazinis URL
OpenAI SDK ir su OpenAI suderinami klientai	`https://api.shannon-ai.com/v1`
Anthropic SDK	`https://api.shannon-ai.com`

Tekstą kuria trys galiniai taškai. Jie pasiekia tuos pačius modelius; rinkitės tą, kurio formatą jūsų kodas jau naudoja.

Galutinis taškas	Formatas
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Išsiųskite pirmąją užklausą

Išsiųskite vieną user pranešimą shannon-3 galiniame taške Chat Completions. Vietoj YOUR_API_KEY įrašykite savo raktą.

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

Laukas	Tipas	Numatytoji	Aprašymas
`model`	`string`		Atsakysiančio modelio id. Id išvardyti puslapyje Modeliai ir kainos.
`messages`	`array`		Pokalbis iki šiol: objektai su `role` ir `content`. Paskutinis `user` pranešimas yra užklausa. Privaloma.
`max_tokens`	`integer`	`4096`	Užklausos išvesties biudžetas, nuo 1 iki 65,536. Užklausa rezervuoja šią sumą iš jūsų balanso ir apmokestinama už tai, ką iš tikrųjų panaudojo.
`stream`	`boolean`	`false`	`true` atsakymą siunčia dalimis, kol jis rašomas.

Užklausos turinys yra JSON ir jam reikia antraštės Content-Type: application/json. Pilnas laukų sąrašas pateiktas galinio taško puslapyje. Chat Completions

Atsakymas

Kreipinys be stream grąžina vieną JSON objektą, kai atsakymas baigtas. Toliau pateikti tekstai ir skaičiai yra pavyzdžiai.

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

Laukas	Tipas	Aprašymas
`id`	`string`	`chatcmpl-` ir 32 šešioliktainiai simboliai.
`object`	`string`	Visada `chat.completion`.
`created`	`integer`	Atsakymo laikas Unix sekundėmis.
`model`	`string`	Atsakiusio modelio paskelbtas id, taip pat tada, kai siuntėte slapyvardį ar kitą užrašymo būdą.
`choices`	`array`	Visada vienas įrašas su `index` 0.
`choices[0].message.role`	`string`	Visada `assistant`.
`choices[0].message.content`	`string \| null`	Atsakymas. Gali būti `null`, kai atsakyme yra `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Modelio mąstymas prieš atsakymą arba `null`, kai jo nėra.
`choices[0].message.tool_calls`	`array`	Yra tik tada, kai modelis kviečia vieną iš jūsų deklaruotų įrankių.
`choices[0].finish_reason`	`string`	`stop` atsakymui, `tool_calls`, kai modelis kviečia įrankį.
`usage.prompt_tokens`	`integer`	Tokenai, kuriuos modelis perskaitė šiam atsakymui. Su `shannon-2-*` ir Shannon 3 šeima jų gali būti daugiau nei jūsų išsiųstame tekste.
`usage.completion_tokens`	`integer`	Tokenai, kuriuos parašė modelis.
`usage.total_tokens`	`integer`	Bendra suma. Shannon modelio mokestis skaičiuojamas pagal šį skaičių.

usage rodo tokenų skaičių, o ne pinigus. Ką kreipinys paėmė iš jūsų balanso, rodoma kiekvienai užklausai puslapyje Raktai ir naudojimas; kaip tai skaičiuojama, aprašyta skyriuje Ribos ir balansas. Ribos ir balansas
Kiekvienas atsakymas, taip pat klaida ir srautas, turi antraštę x-request-id. Jei jūsų užklausoje yra antraštė x-request-id, grįžta jos reikšmė; kitaip reikšmė yra 12 šešioliktainių simbolių. Saugokite ją žurnaluose: ji įvardija būtent šią užklausą.

Tas pats kreipinys kaip srautas

Nustatykite stream į true, kad atsakymą skaitytumėte, kol jis rašomas. Visa kita užklausoje lieka tokia pati.

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

Kiekvienas srauto kadras yra viena eilutė, prasidedanti data: ir talpinanti JSON objektą. Vienas kadras, atspausdintas keliose eilutėse:

Vienas kadras

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

Kadrai paeiliui	delta	finish_reason
Kol modelis mąsto. Nulis ar daugiau kadrų.	`{"reasoning_content": "…"}`	`null`
Atsakymas dalimis. Nulis ar daugiau kadrų.	`{"content": "…"}`	`null`
Paskutinis JSON kadras. Jame taip pat yra `usage`; jo prašyti nereikia.	`{}`	`"stop"`
Srauto pabaiga: eilutė `data: [DONE]`.

Atsakymas turi būseną 200 ir content-type: text/event-stream. Kiekvienas kadras yra eilutė data: <json>, po kurios eina tuščia eilutė.
Eilutė : ping ateina kas 15 sekundžių. Tai komentaras, palaikantis ryšį atvirą; SSE klientai jį praleidžia.
Nesėkmė, įvykusi atsidarius srautui, ateina kaip kadras data: {"error": {…}}. Būsena lieka 200, todėl tikrinkite kadrus.

Srautinė transliacija

Jei kreipinys nepavyksta

Klaida yra JSON objektas su error, kuriame yra type ir message. Tai atsakymai, su kuriais pirmasis kreipinys susiduria dažniausiai.

Būsena	Tipas	Pranešimas	Ką reiškia
`401`	`authentication_error`	`Missing authentication`	Joks raktas nepasiekė API. Siųskite `Authorization: Bearer` ir savo raktą.
`401`	`authentication_error`	`Invalid API key`	Raktas nėra dabartinis paskyros raktas. Nukopijuokite jį iš naujo iš puslapio Raktai ir naudojimas.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` nėra paskelbtas id. Naudokite id iš puslapio Modeliai ir kainos.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Laukas turi netinkamą JSON tipą arba trūksta `messages`.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Užklausos išvesties biudžetas netelpa į jūsų balansą.

Klaidų tvarkymas

Kur eiti toliau

Modeliai ir kainos — Pasirinkite modelį: id, konteksto langai ir kainos.
Chat Completions — Kiekvienas jūsų iškviesto galinio taško užklausos laukas, atsakymo laukas ir srauto įvykis.
Srautinė transliacija — Srauto kadrai, palaikymo eilutės ir klaidos sraute.
Funkcijų kvietimas — Leiskite modeliui kviesti jūsų funkcijas.
Ribos ir balansas — Ką užklausa rezervuoja ir kiek kainuoja, ir kiek užklausų galite siųsti.
API žaidimų aikštelė — Išbandykite užklausas naršyklėje su savo raktu.