Rýchly štart

Urobte prvý request: získajte kľúč, pošlite jednu správu a prečítajte odpoveď. API hovorí formátmi OpenAI a Anthropic, takže SDK, ktoré už používate, funguje po zmene základnej URL a kľúča.

1. Získajte kľúč

Každý účet má jeden API kľúč. Prihláste sa, otvorte Kľúče a využitie a skopírujte ho. Kľúč funguje na každom endpointe a každom modeli. Kľúče a využitie

2. Nasmerujte klienta na API

Všetky endpointy sídlia pod jednou základnou URL. SDK OpenAI ju berie s /v1 na konci; SDK Anthropic bez neho, pretože /v1/messages pridáva samo.

Klient	Základná URL
SDK OpenAI a klienti kompatibilní s OpenAI	`https://api.shannon-ai.com/v1`
SDK Anthropic	`https://api.shannon-ai.com`

Text tvoria tri endpointy. Dosiahnu tie isté modely; vyberte ten, ktorého formát váš kód už používa.

Endpoint	Formát
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Pošlite prvý request

Pošlite jednu správu user na shannon-3 na endpointe Chat Completions. Nahraďte YOUR_API_KEY svojím kľúčom.

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

Pole	Typ	Predvolené	Popis
`model`	`string`		Id modelu, ktorý odpovedá. Id sú uvedené na stránke Modely a ceny.
`messages`	`array`		Konverzácia doteraz: objekty s `role` a `content`. Posledná správa `user` je prompt. Povinné.
`max_tokens`	`integer`	`4096`	Výstupný rozpočet requestu, od 1 do 65,536. Request si túto sumu rezervuje z vášho zostatku a účtuje sa mu to, čo skutočne použil.
`stream`	`boolean`	`false`	`true` posiela odpoveď po kúskoch, kým sa píše.

Telo requestu je JSON a vyžaduje hlavičku Content-Type: application/json. Úplný zoznam polí je na stránke endpointu. Chat Completions

Odpoveď

Volanie bez stream vráti jeden objekt JSON, keď je odpoveď úplná. Texty a čísla nižšie sú príklady.

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

Pole	Typ	Popis
`id`	`string`	`chatcmpl-` a za ním 32 hexadecimálnych znakov.
`object`	`string`	Vždy `chat.completion`.
`created`	`integer`	Čas odpovede v sekundách Unix.
`model`	`string`	Zverejnené id modelu, ktorý odpovedal, aj keď ste poslali alias alebo iný zápis.
`choices`	`array`	Vždy jeden záznam, s `index` 0.
`choices[0].message.role`	`string`	Vždy `assistant`.
`choices[0].message.content`	`string \| null`	Odpoveď. Môže byť `null`, keď odpoveď nesie `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Uvažovanie modelu pred odpoveďou, alebo `null`, keď žiadne nie je.
`choices[0].message.tool_calls`	`array`	Prítomné len keď model volá jeden z nástrojov, ktoré ste deklarovali.
`choices[0].finish_reason`	`string`	`stop` pre odpoveď, `tool_calls` keď model volá nástroj.
`usage.prompt_tokens`	`integer`	Tokeny, ktoré model pre túto odpoveď prečítal. Na `shannon-2-*` a rodine Shannon 3 to môže byť viac než text, ktorý ste poslali.
`usage.completion_tokens`	`integer`	Tokeny, ktoré model napísal.
`usage.total_tokens`	`integer`	Súčet. Z tohto čísla sa počíta poplatok modelu Shannon.

usage obsahuje počty tokenov, nie peniaze. Čo volanie vzalo z vášho zostatku, ukazuje stránka Kľúče a využitie pri každom requeste; ako sa počíta, je na stránke Limity a zostatok. Limity a zostatok
Každá odpoveď, aj chyba a stream, má hlavičku x-request-id. Ak váš request nesie hlavičku x-request-id, vráti sa jej hodnota; inak je hodnota 12 hexadecimálnych znakov. Uchovajte ju vo svojich logoch: pomenúva tento jeden request.

To isté volanie ako stream

Nastavte stream na true, aby ste čítali odpoveď, kým sa píše. Všetko ostatné v requeste zostáva rovnaké.

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

Každý frame streamu je jeden riadok, ktorý začína data: a obsahuje objekt JSON. Jeden frame, vypísaný na viacerých riadkoch:

Jeden frame

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

Frames v poradí	delta	finish_reason
Kým model uvažuje. Nula alebo viac frames.	`{"reasoning_content": "…"}`	`null`
Odpoveď po kúskoch. Nula alebo viac frames.	`{"content": "…"}`	`null`
Posledný frame JSON. Nesie aj `usage`; nemusíte oň žiadať.	`{}`	`"stop"`
Koniec streamu: riadok `data: [DONE]`.

Odpoveď má status 200 a content-type: text/event-stream. Každý frame je riadok data: <json> nasledovaný prázdnym riadkom.
Každých 15 sekúnd príde riadok : ping. Je to komentár, ktorý drží spojenie otvorené; klienti SSE ho preskočia.
Zlyhanie po otvorení streamu príde ako frame data: {"error": {…}}. Status zostáva 200, preto kontrolujte frames.

Streamovanie

Ak volanie zlyhá

Chyba je objekt JSON s error, ktorý obsahuje type a message. Toto sú odpovede, na ktoré prvé volanie najčastejšie narazí.

Stav	Typ	Správa	Čo znamená
`401`	`authentication_error`	`Missing authentication`	Na API nedorazil žiadny kľúč. Pošlite `Authorization: Bearer` a za ním váš kľúč.
`401`	`authentication_error`	`Invalid API key`	Kľúč nie je aktuálny kľúč žiadneho účtu. Skopírujte ho znova zo stránky Kľúče a využitie.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` nie je zverejnené id. Použite id zo stránky Modely a ceny.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Pole má nesprávny typ JSON, alebo chýba `messages`.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Výstupný rozpočet requestu sa nezmestí do vášho zostatku.

Spracovanie chýb

Kam ďalej

Modely a ceny — Vyberte model: id, kontextové okná a ceny.
Chat Completions — Každé pole requestu, pole odpovede a udalosť streamu endpointu, ktorý ste volali.
Streamovanie — Frames streamu, keep-alive riadky a chyby vo vnútri streamu.
Volanie funkcií — Nechajte model volať vaše funkcie.
Limity a zostatok — Čo request rezervuje a koľko stojí a koľko requestov môžete poslať.
Playground — Vyskúšajte requesty v prehliadači so svojím kľúčom.