Kiirstart

Tee esimene päring: hangi oma võti, saada üks sõnum ja loe vastus. API kõneleb OpenAI ja Anthropic formaate, nii et SDK, mida juba kasutad, töötab pärast seda, kui muudad selle base URL-i ja võtit.

1. Hangi oma võti

Igal kontol on üks API võti. Logi sisse, ava Võtmed ja kasutus ning kopeeri see. Võti töötab igas lõpp-punktis ja igal mudelil. Võtmed ja kasutus

2. Suuna oma klient API-le

Kõik lõpp-punktid asuvad ühe base URL-i all. OpenAI SDK võtab selle /v1-ga lõpus; Anthropic SDK võtab ilma, sest see lisab /v1/messages ise.

Klient	Base URL
OpenAI SDK-d ja OpenAI-ühilduvad kliendid	`https://api.shannon-ai.com/v1`
Anthropic SDK-d	`https://api.shannon-ai.com`

Teksti toodavad kolm lõpp-punkti. Nad jõuavad samade mudeliteni; vali see, mille formaati sinu kood juba kasutab.

Lõpppunkt	Formaat
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Saada esimene päring

Saada üks user-sõnum mudelile shannon-3 lõpp-punktis Chat Completions. Asenda YOUR_API_KEY oma võtmega.

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

Väli	Tüüp	Vaikeväärtus	Kirjeldus
`model`	`string`		Mudeli id, mis vastab. Id-d on loetletud lehel Mudelid ja hinnad.
`messages`	`array`		Vestlus siiani: objektid väljadega `role` ja `content`. Viimane `user`-sõnum on prompt. Nõutav.
`max_tokens`	`integer`	`4096`	Päringu väljundi eelarve, vahemikus 1 kuni 65,536. Päring reserveerib selle summa sinu saldost ja selle eest arveldatakse tegelikult kasutatu.
`stream`	`boolean`	`false`	`true` saadab vastuse tükkhaaval, kuni seda kirjutatakse.

Päringu sisu on JSON ja vajab päist Content-Type: application/json. Väljade täielik loend on lõpp-punkti lehel. Chat Completions

Vastus

Kõne ilma stream-ita tagastab ühe JSON-objekti, kui vastus on valmis. Allolevad tekstid ja arvud on näited.

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

Väli	Tüüp	Kirjeldus
`id`	`string`	`chatcmpl-`, millele järgneb 32 kuueteistkümnendsüsteemi märki.
`object`	`string`	Alati `chat.completion`.
`created`	`integer`	Vastuse aeg Unix-sekundites.
`model`	`string`	Vastanud mudeli avaldatud id, ka siis, kui saatsid aliase või muu kirjaviisi.
`choices`	`array`	Alati üks kirje, mille `index` on 0.
`choices[0].message.role`	`string`	Alati `assistant`.
`choices[0].message.content`	`string \| null`	Vastus. See võib olla `null`, kui vastus kannab `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Mudeli arutlus enne vastust või `null`, kui seda ei ole.
`choices[0].message.tool_calls`	`array`	Olemas ainult siis, kui mudel kutsub ühte sinu deklareeritud tööriistadest.
`choices[0].finish_reason`	`string`	`stop` vastuse puhul, `tool_calls`, kui mudel kutsub tööriista.
`usage.prompt_tokens`	`integer`	Tokenid, mille mudel selle vastuse jaoks luges. Mudelitel `shannon-2-*` ja Shannon 3 perekonnal võib see olla rohkem kui sinu saadetud tekst.
`usage.completion_tokens`	`integer`	Tokenid, mille mudel kirjutas.
`usage.total_tokens`	`integer`	Kokku. Shannoni mudeli hind arvutatakse sellest arvust.

usage sisaldab tokenite arvu, mitte raha. Mida kõne sinu saldost võttis, on näidatud päringu kohta lehel Võtmed ja kasutus; kuidas see arvutatakse, on lehel Piirangud ja saldo. Piirangud ja saldo
Igal vastusel, ka veal ja voos, on päis x-request-id. Kui sinu päring kannab päist x-request-id, tuleb selle väärtus tagasi; muidu on väärtus 12 kuueteistkümnendsüsteemi märki. Hoia seda oma logides: see nimetab just seda üht päringut.

Sama kõne voona

Määra stream väärtuseks true, et lugeda vastust, kuni seda kirjutatakse. Kõik muu päringus jääb samaks.

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

Voo iga kaader on üks rida, mis algab data: ja sisaldab JSON-objekti. Üks kaader, trükitud mitmele reale:

Üks kaader

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

Kaadrid järjekorras	delta	finish_reason
Kuni mudel arutleb. Null või rohkem kaadrit.	`{"reasoning_content": "…"}`	`null`
Vastus tükkhaaval. Null või rohkem kaadrit.	`{"content": "…"}`	`null`
Viimane JSON-kaader. See kannab ka `usage`; seda ei pea küsima.	`{}`	`"stop"`
Voo lõpp: rida `data: [DONE]`.

Vastuse olek on 200 ja content-type: text/event-stream. Iga kaader on rida data: <json>, millele järgneb tühi rida.
Rida : ping saabub iga 15 sekundi järel. See on kommentaar, mis hoiab ühenduse avatuna; SSE kliendid jätavad selle vahele.
Tõrge pärast voo avanemist saabub kaadrina data: {"error": {…}}. Olek jääb 200, seega kontrolli kaadreid.

Voogedastus

Kui kõne ebaõnnestub

Viga on JSON-objekt, mille error sisaldab type ja message. Need on vastused, millega esimene kõne kõige sagedamini kokku puutub.

Olek	Tüüp	Teade	Mida see tähendab
`401`	`authentication_error`	`Missing authentication`	Ükski võti ei jõudnud API-ni. Saada `Authorization: Bearer`, millele järgneb sinu võti.
`401`	`authentication_error`	`Invalid API key`	Võti ei ole konto kehtiv võti. Kopeeri see uuesti lehelt Võtmed ja kasutus.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` ei ole avaldatud id. Kasuta id-d lehelt Mudelid ja hinnad.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Väljal on vale JSON-tüüp või `messages` puudub.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Päringu väljundi eelarve ei mahu sinu saldosse.

Vigade käsitlus

Kuhu edasi

Mudelid ja hinnad — Vali mudel: id-d, kontekstiaknad ja hinnad.
Chat Completions — Iga päringuväli, vastuseväli ja voosündmus lõpp-punktis, mida kutsusid.
Voogedastus — Voo kaadrid, keep-alive read ja vead voo sees.
Funktsioonikutse — Lase mudelil kutsuda sinu funktsioone.
Piirangud ja saldo — Mida päring reserveerib ja mis see maksab ning mitu päringut võid saata.
API mänguväljak — Proovi päringuid brauseris oma võtmega.