Vinnige begin

Maak 'n eerste versoek: kry jou sleutel, stuur een boodskap en lees die antwoord. Die API praat die OpenAI- en Anthropic-formate, so die SDK wat jy reeds gebruik, werk nadat jy sy basis-URL en sleutel verander het.

1. Kry jou sleutel

Elke rekening het een API-sleutel. Meld aan, maak Sleutels en gebruik oop en kopieer dit. Die sleutel werk op elke eindpunt en elke model. Sleutels en gebruik

2. Rig jou kliënt na die API

Alle eindpunte woon onder een basis-URL. 'n OpenAI-SDK neem dit met /v1 aan die einde; 'n Anthropic-SDK neem dit daarsonder, omdat dit self /v1/messages byvoeg.

Kliënt	Basis-URL
OpenAI-SDK's en OpenAI-versoenbare kliënte	`https://api.shannon-ai.com/v1`
Anthropic-SDK's	`https://api.shannon-ai.com`

Drie eindpunte lewer teks. Hulle bereik dieselfde modelle; kies die een waarvan die formaat jou kode reeds gebruik.

Eindpunt	Formaat
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Stuur 'n eerste versoek

Stuur een user-boodskap na shannon-3 op die Chat Completions-eindpunt. Vervang YOUR_API_KEY met jou sleutel.

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

Veld	Tipe	Verstek	Beskrywing
`model`	`string`		Die id van die model wat antwoord. Die id's word op Modelle en pryse gelys.
`messages`	`array`		Die gesprek tot dusver: objekte met `role` en `content`. Die laaste `user`-boodskap is die prompt. Vereis.
`max_tokens`	`integer`	`4096`	Die uitvoerbegroting van die versoek, van 1 tot 65,536. Die versoek reserveer hierdie bedrag van jou balans en word gehef vir wat dit werklik gebruik het.
`stream`	`boolean`	`false`	`true` stuur die antwoord stuk vir stuk terwyl dit geskryf word.

Die versoekliggaam is JSON en het die header Content-Type: application/json nodig. Die volledige lys velde is op die eindpuntbladsy. Chat Completions

Die antwoord

'n Oproep sonder stream gee een JSON-objek terug wanneer die antwoord volledig is. Die tekste en getalle hieronder is voorbeelde.

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

Veld	Tipe	Beskrywing
`id`	`string`	`chatcmpl-` gevolg deur 32 heksadesimale karakters.
`object`	`string`	Altyd `chat.completion`.
`created`	`integer`	Die tyd van die antwoord in Unix-sekondes.
`model`	`string`	Die gepubliseerde id van die model wat geantwoord het, ook wanneer jy 'n alias of 'n ander spelling gestuur het.
`choices`	`array`	Altyd een inskrywing, met `index` 0.
`choices[0].message.role`	`string`	Altyd `assistant`.
`choices[0].message.content`	`string \| null`	Die antwoord. Dit kan `null` wees wanneer die antwoord `tool_calls` dra.
`choices[0].message.reasoning_content`	`string \| null`	Die redenering van die model voor sy antwoord, of `null` wanneer daar geen is nie.
`choices[0].message.tool_calls`	`array`	Net teenwoordig wanneer die model een van die gereedskap oproep wat jy verklaar het.
`choices[0].finish_reason`	`string`	`stop` vir 'n antwoord, `tool_calls` wanneer die model 'n gereedskap oproep.
`usage.prompt_tokens`	`integer`	Die tokens wat die model vir hierdie antwoord gelees het. Op `shannon-2-*` en die Shannon 3-familie kan dit meer wees as die teks wat jy gestuur het.
`usage.completion_tokens`	`integer`	Die tokens wat die model geskryf het.
`usage.total_tokens`	`integer`	Die totaal. Die heffing van 'n Shannon-model word uit hierdie getal bereken.

usage hou tokengetalle, nie geld nie. Wat die oproep van jou balans geneem het, word per versoek op Sleutels en gebruik gewys; hoe dit bereken word, is op Perke en balans. Perke en balans
Elke antwoord, ook 'n fout en 'n stroom, het die header x-request-id. As jou versoek 'n x-request-id-header dra, kom sy waarde terug; anders is die waarde 12 heksadesimale karakters. Hou dit in jou logs: dit noem hierdie een versoek.

Dieselfde oproep as 'n stroom

Stel stream op true om die antwoord te lees terwyl dit geskryf word. Alles anders in die versoek bly dieselfde.

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

Elke raam van die stroom is een reël wat met data: begin en 'n JSON-objek hou. Een raam, op verskeie reëls gedruk:

Een raam

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

Rame, in volgorde	delta	finish_reason
Terwyl die model redeneer. Nul of meer rame.	`{"reasoning_content": "…"}`	`null`
Die antwoord, stuk vir stuk. Nul of meer rame.	`{"content": "…"}`	`null`
Die laaste JSON-raam. Dit dra ook `usage`; jy hoef nie daarvoor te vra nie.	`{}`	`"stop"`
Die einde van die stroom: die reël `data: [DONE]`.

Die antwoord het status 200 en content-type: text/event-stream. Elke raam is 'n reël data: <json> gevolg deur 'n leë reël.
'n Reël : ping kom elke 15 sekondes aan. Dit is 'n kommentaar wat die verbinding oop hou; SSE-kliënte slaan dit oor.
'n Mislukking nadat die stroom oopgemaak is, kom as 'n raam data: {"error": {…}} aan. Die status bly 200, so toets die rame.

Stroming

As die oproep misluk

'n Fout is 'n JSON-objek met 'n error wat type en message hou. Dit is die antwoorde wat 'n eerste oproep die meeste teëkom.

Status	Tipe	Boodskap	Wat dit beteken
`401`	`authentication_error`	`Missing authentication`	Geen sleutel het die API bereik nie. Stuur `Authorization: Bearer` gevolg deur jou sleutel.
`401`	`authentication_error`	`Invalid API key`	Die sleutel is nie die huidige sleutel van 'n rekening nie. Kopieer dit weer van Sleutels en gebruik.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` is nie 'n gepubliseerde id nie. Gebruik 'n id van Modelle en pryse.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	'n Veld het die verkeerde JSON-tipe, of `messages` ontbreek.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Die uitvoerbegroting van die versoek pas nie in jou balans in nie.

Fouthantering

Waarheen om volgende te gaan

Modelle en pryse — Kies 'n model: id's, konteksvensters en pryse.
Chat Completions — Elke versoekveld, antwoordveld en stroomgebeurtenis van die eindpunt wat jy opgeroep het.
Stroming — Die rame van 'n stroom, keep-alive-reëls en foute binne 'n stroom.
Funksie-oproepe — Laat die model jou funksies oproep.
Perke en balans — Wat 'n versoek reserveer en kos, en hoeveel versoeke jy mag stuur.
API‑speelgrond — Probeer versoeke in die blaaier met jou sleutel.