Schnellstart

Maacht eng éischt Ufro: kritt Äre Schlëssel, schéckt eng Message a liest d'Äntwert. D'API schwätzt d'OpenAI- an d'Anthropic-Formater, sou datt d'SDK, déi Dir scho benotzt, funktionéiert, nodeems Dir hir Basis-URL an de Schlëssel geännert hutt.

1. Äre Schlëssel kréien

All Kont huet een API-Schlëssel. Mellt Iech un, maacht Schlësselen & Notzung op a kopéiert en. De Schlëssel funktionéiert op all Endpoint a bei all Modell. Schlësselen & Notzung

2. Riicht Äre Client op d'API

All Endpoints leien ënner enger Basis-URL. En OpenAI-SDK hëlt se mat /v1 um Enn; en Anthropic-SDK hëlt se ouni, well en /v1/messages selwer derbäisetzt.

Client	Basis-URL
OpenAI-SDKs an OpenAI-kompatibel Clienten	`https://api.shannon-ai.com/v1`
Anthropic-SDKs	`https://api.shannon-ai.com`

Dräi Endpoints produzéieren Text. Si erreechen déiselwecht Modeller; wielt deen, dessen Format Äre Code scho benotzt.

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

3. Eng éischt Ufro schécken

Schéckt eng user-Message un shannon-3 um Chat-Completions-Endpoint. Ersetzt YOUR_API_KEY duerch Äre Schlëssel.

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

Feld	Typ	Standard	Beschreiwung
`model`	`string`		D'ID vum Modell, dat äntwert. D'IDen stinn op Modeller & Präisser.
`messages`	`array`		D'Konversatioun bis elo: Objeten mat `role` an `content`. Déi lescht `user`-Message ass de Prompt. Erfuerderlech.
`max_tokens`	`integer`	`4096`	Den Output-Budget vun der Ufro, vun 1 bis 65,536. D'Ufro reservéiert dëse Betrag aus Ärem Solde a gëtt fir dat berechent, wat si wierklech benotzt huet.
`stream`	`boolean`	`false`	`true` schéckt d'Äntwert Stéck fir Stéck, wéi se geschriwwe gëtt.

De Body vun der Ufro ass JSON a brauch den Header Content-Type: application/json. Déi komplett Lëscht vun de Felder steet op der Säit vum Endpoint. Chat Completions

D'Äntwert

E Ruff ouni stream gëtt ee JSON-Objet zréck, wann d'Äntwert komplett ass. D'Texter an d'Zuelen ënnendrënner si Beispiller.

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

Feld	Typ	Beschreiwung
`id`	`string`	`chatcmpl-` gefollegt vun 32 hexadezimale Zeechen.
`object`	`string`	Ëmmer `chat.completion`.
`created`	`integer`	D'Zäit vun der Äntwert a Unix-Sekonnen.
`model`	`string`	Déi publizéiert ID vum Modell, dat geäntwert huet, och wann Dir en Alias oder eng aner Schreifweis geschéckt hutt.
`choices`	`array`	Ëmmer een Eintrag, mat `index` 0.
`choices[0].message.role`	`string`	Ëmmer `assistant`.
`choices[0].message.content`	`string \| null`	D'Äntwert. Et kann `null` sinn, wann d'Äntwert `tool_calls` enthält.
`choices[0].message.reasoning_content`	`string \| null`	D'Reasoning vum Modell virun senger Äntwert, oder `null`, wann et keng gëtt.
`choices[0].message.tool_calls`	`array`	Nëmmen do, wann de Modell een vun den Tools rifft, déi Dir deklaréiert hutt.
`choices[0].finish_reason`	`string`	`stop` fir eng Äntwert, `tool_calls`, wann de Modell en Tool rifft.
`usage.prompt_tokens`	`integer`	D'Tokens, déi de Modell fir dës Äntwert gelies huet. Bei `shannon-2-*` an der Shannon-3-Famill kann dat méi sinn, wéi den Text, deen Dir geschéckt hutt.
`usage.completion_tokens`	`integer`	D'Tokens, déi de Modell geschriwwen huet.
`usage.total_tokens`	`integer`	D'Zomm. D'Berechnung vun engem Shannon-Modell gëtt aus dëser Zuel gemaach.

usage enthält Tokenzuelen, kee Geld. Wat de Ruff aus Ärem Solde geholl huet, gëtt pro Ufro op Schlësselen & Notzung gewisen; wéi et berechent gëtt, steet op Limiten a Solde. Limiten a Solde
All Äntwert, och e Feeler an e Stream, huet den Header x-request-id. Wann Är Ufro en x-request-id-Header enthält, kënnt säi Wäert zréck; soss besteet de Wäert aus 12 hexadezimale Zeechen. Haalt en an Ären Logs: en nennt genau dës eng Ufro.

Dee selwechte Ruff als Stream

Setzt stream op true, fir d'Äntwert ze liesen, wärend se geschriwwe gëtt. Alles anert an der Ufro bleift datselwecht.

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

All Frame vum Stream ass eng Zeil, déi mat data: ufänkt an e JSON-Objet enthält. Ee Frame, op e puer Zeilen gedréckt:

Ee Frame

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

Frames, der Reiefolleg no	delta	finish_reason
Wärend de Modell reasonéiert. Null oder méi Frames.	`{"reasoning_content": "…"}`	`null`
D'Äntwert, Stéck fir Stéck. Null oder méi Frames.	`{"content": "…"}`	`null`
Dee leschte JSON-Frame. Hie enthält och `usage`; Dir musst net dorëms froen.	`{}`	`"stop"`
D'Enn vum Stream: d'Zeil `data: [DONE]`.

D'Äntwert huet de Status 200 an content-type: text/event-stream. All Frame ass eng Zeil data: <json> gefollegt vun enger eideler Zeil.
All 15 Sekonne kënnt eng Zeil : ping. Et ass e Kommentar, deen d'Verbindung oppen hält; SSE-Clienten iwwersprangen en.
E Feeler, nodeems de Stream opgaangen ass, kënnt als Frame data: {"error": {…}}. De Status bleift 200, kontrolléiert dofir d'Frames.

Streaming

Wann de Ruff feelschléit

E Feeler ass e JSON-Objet mat engem error, deen type a message enthält. Dat sinn d'Äntwerten, op déi en éischte Ruff am meeschte stéisst.

Status	Typ	Message	Wat et bedeit
`401`	`authentication_error`	`Missing authentication`	Et ass kee Schlëssel bei der API ukomm. Schéckt `Authorization: Bearer` gefollegt vun Ärem Schlëssel.
`401`	`authentication_error`	`Invalid API key`	De Schlëssel ass net deen aktuelle Schlëssel vun engem Kont. Kopéiert en nach eng Kéier aus Schlësselen & Notzung.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` ass keng publizéiert ID. Benotzt eng ID aus Modeller & Präisser.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	E Feld huet de falsche JSON-Typ, oder `messages` feelt.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Den Output-Budget vun der Ufro passt net an Äre Solde.

Feelerbehandlung

Wou et weidergeet

Modeller a Präisser — E Modell auswielen: IDen, Kontextfënsteren a Präisser.
Chat Completions — All Ufro-Feld, Äntwert-Feld a Stream-Event vum Endpoint, dee Dir geruff hutt.
Streaming — D'Frames vun engem Stream, Keep-alive-Zeilen a Feeler an engem Stream.
Funktiounsofruff — De Modell Är Funktiounen ruffe loossen.
Limiten a Solde — Wat eng Ufro reservéiert a kascht, a wéi vill Ufroe Dir däerft schécken.
API-Playground — Ufroen am Browser mat Ärem Schlëssel ausprobéieren.