Szybki start

Wyślij pierwsze zapytanie: weź klucz, wyślij jedną wiadomość i przeczytaj odpowiedź. API mówi formatami OpenAI i Anthropic, więc SDK, którego już używasz, działa po zmianie base URL i klucza.

1. Weź klucz

Każde konto ma jeden klucz API. Zaloguj się, otwórz Keys & usage i skopiuj go. Klucz działa w każdym endpoincie i w każdym modelu. Keys & usage

2. Wskaż klientowi API

Wszystkie endpointy znajdują się pod jednym base URL. SDK OpenAI przyjmuje go z /v1 na końcu; SDK Anthropic przyjmuje go bez, ponieważ samo dodaje /v1/messages.

Klient	Base URL
SDK OpenAI i klienci zgodni z OpenAI	`https://api.shannon-ai.com/v1`
SDK Anthropic	`https://api.shannon-ai.com`

Tekst generują trzy endpointy. Docierają do tych samych modeli; wybierz ten, którego formatu już używa Twój kod.

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

3. Wyślij pierwsze zapytanie

Wyślij jedną wiadomość user do shannon-3 w endpoincie Chat Completions. Zastąp YOUR_API_KEY swoim kluczem.

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	Domyślnie	Opis
`model`	`string`		Id modelu, który odpowiada. Id są wymienione na stronie Models & pricing.
`messages`	`array`		Dotychczasowa rozmowa: obiekty z `role` i `content`. Ostatnia wiadomość `user` to prompt. Wymagane.
`max_tokens`	`integer`	`4096`	Budżet wyjścia zapytania, od 1 do 65,536. Zapytanie rezerwuje tę kwotę z Twojego salda i jest rozliczane za to, co naprawdę zużyło.
`stream`	`boolean`	`false`	`true` wysyła odpowiedź kawałek po kawałku w trakcie pisania.

Treść zapytania to JSON i wymaga nagłówka Content-Type: application/json. Pełna lista pól jest na stronie endpointu. Chat Completions

Odpowiedź

Wywołanie bez stream zwraca jeden obiekt JSON, gdy odpowiedź jest kompletna. Teksty i liczby poniżej to przykłady.

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	Opis
`id`	`string`	`chatcmpl-` i po nim 32 znaki szesnastkowe.
`object`	`string`	Zawsze `chat.completion`.
`created`	`integer`	Czas odpowiedzi w sekundach Unix.
`model`	`string`	Opublikowane id modelu, który odpowiedział, także gdy wysłano alias lub inny zapis.
`choices`	`array`	Zawsze jeden wpis, z `index` 0.
`choices[0].message.role`	`string`	Zawsze `assistant`.
`choices[0].message.content`	`string \| null`	Odpowiedź. Może być `null`, gdy odpowiedź zawiera `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Wnioskowanie modelu przed odpowiedzią albo `null`, gdy go nie ma.
`choices[0].message.tool_calls`	`array`	Obecne tylko wtedy, gdy model wywołuje jedno z zadeklarowanych przez Ciebie narzędzi.
`choices[0].finish_reason`	`string`	`stop` dla odpowiedzi, `tool_calls`, gdy model wywołuje narzędzie.
`usage.prompt_tokens`	`integer`	Tokeny, które model przeczytał do tej odpowiedzi. W `shannon-2-*` i rodzinie Shannon 3 może to być więcej niż wysłany tekst.
`usage.completion_tokens`	`integer`	Tokeny, które napisał model.
`usage.total_tokens`	`integer`	Suma. Koszt modelu Shannon jest liczony z tej liczby.

usage zawiera liczby tokenów, nie pieniądze. To, co wywołanie zabrało z Twojego salda, jest pokazane przy każdym zapytaniu w Keys & usage; jak to się liczy, opisuje strona Limity i saldo. Limity i saldo
Każda odpowiedź, także błąd i stream, ma nagłówek x-request-id. Jeśli Twoje zapytanie niesie nagłówek x-request-id, jego wartość wraca; w przeciwnym razie wartość to 12 znaków szesnastkowych. Zachowaj ją w logach: wskazuje to jedno zapytanie.

To samo wywołanie jako stream

Ustaw stream na true, aby czytać odpowiedź w trakcie pisania. Wszystko inne w zapytaniu pozostaje bez zmian.

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żda ramka streamu to jeden wiersz zaczynający się od data: i zawierający obiekt JSON. Jedna ramka, wypisana w kilku wierszach:

Jedna ramka

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

Ramki, po kolei	delta	finish_reason
Gdy model wnioskuje. Zero lub więcej ramek.	`{"reasoning_content": "…"}`	`null`
Odpowiedź, kawałek po kawałku. Zero lub więcej ramek.	`{"content": "…"}`	`null`
Ostatnia ramka JSON. Niesie też `usage`; nie musisz o to prosić.	`{}`	`"stop"`
Koniec streamu: wiersz `data: [DONE]`.

Odpowiedź ma status 200 i content-type: text/event-stream. Każda ramka to wiersz data: <json> i po nim pusty wiersz.
Wiersz : ping przychodzi co 15 sekund. To komentarz, który utrzymuje połączenie otwarte; klienci SSE go pomijają.
Awaria po otwarciu streamu przychodzi jako ramka data: {"error": {…}}. Status pozostaje 200, więc sprawdzaj ramki.

Streaming

Gdy wywołanie się nie powiedzie

Błąd to obiekt JSON z polem error, które zawiera type i message. To odpowiedzi, na które pierwsze wywołanie trafia najczęściej.

Status	Typ	Komunikat	Co oznacza
`401`	`authentication_error`	`Missing authentication`	Do API nie dotarł żaden klucz. Wyślij `Authorization: Bearer` i po nim swój klucz.
`401`	`authentication_error`	`Invalid API key`	Klucz nie jest bieżącym kluczem żadnego konta. Skopiuj go ponownie z Keys & usage.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` nie jest opublikowanym id. Użyj id ze strony Models & pricing.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Pole ma błędny typ JSON albo brakuje `messages`.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Budżet wyjścia zapytania nie mieści się w Twoim saldzie.

Obsługa błędów

Dokąd dalej

Modele i ceny — Wybierz model: id, okna kontekstu i ceny.
Chat Completions — Każde pole zapytania, pole odpowiedzi i zdarzenie streamu endpointu, który wywołałeś.
Streaming — Ramki streamu, linie keep-alive i błędy wewnątrz streamu.
Wywołanie funkcji — Pozwól modelowi wywoływać Twoje funkcje.
Limity i saldo — Co zapytanie rezerwuje i ile kosztuje oraz ile zapytań możesz wysyłać.
Plac zabaw API — Wypróbuj zapytania w przeglądarce ze swoim kluczem.