Gyors kezdés

Küldd el az első kérést: szerezd meg a kulcsodat, küldj egy üzenetet, és olvasd el a választ. Az API az OpenAI és az Anthropic formátumot beszéli, így a már használt SDK az alap URL és a kulcs átállítása után működik.

1. Szerezd meg a kulcsodat

Minden fiókhoz egy API-kulcs tartozik. Jelentkezz be, nyisd meg a Keys & usage oldalt, és másold ki. A kulcs minden végponton és minden modellen működik. Keys & usage

2. Irányítsd a klienst az API-ra

Minden végpont egyetlen alap URL alatt van. Az OpenAI SDK a végén /v1 résszel veszi; az Anthropic SDK anélkül, mert a /v1/messages részt maga fűzi hozzá.

Kliens	Alap URL
OpenAI SDK-k és OpenAI-kompatibilis kliensek	`https://api.shannon-ai.com/v1`
Anthropic SDK-k	`https://api.shannon-ai.com`

Három végpont állít elő szöveget. Ugyanazokat a modelleket érik el; azt válaszd, amelynek a formátumát a kódod már használja.

Végpont	Formátum
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Küldd el az első kérést

Küldj egy user üzenetet a shannon-3 modellnek a Chat Completions végponton. Cseréld a YOUR_API_KEY helyőrzőt a saját kulcsodra.

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

Mező	Típus	Alapérték	Leírás
`model`	`string`		A válaszoló modell azonosítója. Az azonosítók a Models & pricing oldalon vannak felsorolva.
`messages`	`array`		A beszélgetés eddig: `role` és `content` mezős objektumok. Az utolsó `user` üzenet a prompt. Kötelező.
`max_tokens`	`integer`	`4096`	A kérés kimeneti kerete, 1-től 65,536-ig. A kérés ezt a mennyiséget lefoglalja az egyenlegedből, és a ténylegesen felhasznált mennyiség után számláz.
`stream`	`boolean`	`false`	A `true` darabonként küldi a választ, ahogy íródik.

A kérés törzse JSON, és a Content-Type: application/json fejlécet igényli. A mezők teljes listája a végpontoldalon van. Chat Completions

A válasz

A stream nélküli hívás egyetlen JSON-objektumot ad vissza, amikor a válasz teljes. Az alábbi szövegek és számok példák.

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

Mező	Típus	Leírás
`id`	`string`	A `chatcmpl-` után 32 hexadecimális karakter áll.
`object`	`string`	Mindig `chat.completion`.
`created`	`integer`	A válasz ideje Unix-másodpercben.
`model`	`string`	A válaszoló modell közzétett azonosítója, akkor is, ha aliast vagy másik írásmódot küldtél.
`choices`	`array`	Mindig egy elem, `index` 0 értékkel.
`choices[0].message.role`	`string`	Mindig `assistant`.
`choices[0].message.content`	`string \| null`	A válasz. Lehet `null`, ha a válasz `tool_calls` mezőt hordoz.
`choices[0].message.reasoning_content`	`string \| null`	A modell gondolkodása (reasoning) a válasza előtt, vagy `null`, ha nincs.
`choices[0].message.tool_calls`	`array`	Csak akkor van jelen, ha a modell az általad megadott eszközök egyikét hívja.
`choices[0].finish_reason`	`string`	`stop` válasz esetén, `tool_calls`, ha a modell eszközt hív.
`usage.prompt_tokens`	`integer`	A tokenek, amelyeket a modell ehhez a válaszhoz elolvasott. A `shannon-2-*` modelleken és a Shannon 3 családnál ez több lehet, mint az általad küldött szöveg.
`usage.completion_tokens`	`integer`	A modell által írt tokenek.
`usage.total_tokens`	`integer`	Az összeg. A Shannon modell díját ebből a számból számolja.

A usage tokenszámokat tartalmaz, nem pénzt. Hogy a hívás mennyit vont le az egyenlegedből, kérésenként a Keys & usage oldalon látod; a számítás módja a Korlátok és egyenleg oldalon van. Korlátok és egyenleg
Minden válasz, a hiba és a stream is, tartalmazza az x-request-id fejlécet. Ha a kérésed x-request-id fejlécet hordoz, az értéke tér vissza; különben az érték 12 hexadecimális karakter. Őrizd meg a naplóidban: ezt az egy kérést nevezi meg.

Ugyanaz a hívás streamként

Állítsd a stream mezőt true értékre, hogy a választ írás közben olvasd. A kérés minden más része változatlan marad.

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

A stream minden frame egy data: előtaggal kezdődő sor, amely egy JSON-objektumot tartalmaz. Egy frame, több sorba írva:

Egy frame

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

Framek, sorrendben	delta	finish_reason
Amíg a modell gondolkodik (reasoning). Nulla vagy több frame.	`{"reasoning_content": "…"}`	`null`
A válasz, darabonként. Nulla vagy több frame.	`{"content": "…"}`	`null`
Az utolsó JSON-frame. Ez a `usage` mezőt is hordozza; nem kell külön kérned.	`{}`	`"stop"`
A stream vége: a `data: [DONE]` sor.

A válasz státusza 200, a fejléce pedig content-type: text/event-stream. Minden frame egy data: <json> sor, utána egy üres sor.
A : ping sor 15 másodpercenként érkezik. Megjegyzés, amely nyitva tartja a kapcsolatot; az SSE-kliensek átugorják.
A stream megnyitása utáni hiba data: {"error": {…}} frameként érkezik. A státusz 200 marad, ezért ellenőrizd a frameket.

Streaming

Ha a hívás hibázik

A hiba egy JSON-objektum, amelynek error mezője type és message értéket tartalmaz. Ezek azok a válaszok, amelyekkel az első hívás leggyakrabban találkozik.

Státusz	Típus	Üzenet	Mit jelent
`401`	`authentication_error`	`Missing authentication`	Nem érkezett kulcs az API-hoz. Küldd az `Authorization: Bearer` fejlécet, utána a kulcsoddal.
`401`	`authentication_error`	`Invalid API key`	A kulcs nem egy fiók jelenlegi kulcsa. Másold ki újra a Keys & usage oldalról.
`400`	`invalid_request_error`	`unknown model: <id>`	A `model` nem közzétett azonosító. Használj egy azonosítót a Models & pricing oldalról.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Egy mező JSON-típusa hibás, vagy a `messages` hiányzik.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	A kérés kimeneti kerete nem fér bele az egyenlegedbe.

Hibakezelés

Merre tovább

Modellek és árak — Válassz modellt: azonosítók, kontextusablakok és árak.
Chat Completions — A hívott végpont minden kérésmezője, válaszmezője és streameseménye.
Streaming — A stream framei, a keep-alive sorok és a streamen belüli hibák.
Funkcióhívás — Engedd, hogy a modell hívja a függvényeidet.
Korlátok és egyenleg — Mit foglal le és mibe kerül egy kérés, és hány kérést küldhetsz.
Playground — Próbálj ki kéréseket a böngészőben a kulcsoddal.