Rapida komenco

Faru unuan peton: akiru vian ŝlosilon, sendu unu mesaĝon kaj legu la respondon. La API parolas la formatojn de OpenAI kaj Anthropic, do la SDK, kiun vi jam uzas, funkcias post kiam vi ŝanĝas ĝian bazan URL kaj ŝlosilon.

1. Akiru vian ŝlosilon

Ĉiu konto havas unu API-ŝlosilon. Ensalutu, malfermu Keys & usage kaj kopiu ĝin. La ŝlosilo funkcias ĉe ĉiu endpoint kaj ĉiu modelo. Ŝlosiloj kaj uzado

2. Direktu vian klienton al la API

Ĉiuj endpoints troviĝas sub unu baza URL. SDK de OpenAI prenas ĝin kun /v1 ĉe la fino; SDK de Anthropic prenas ĝin sen, ĉar ĝi mem aldonas /v1/messages.

Kliento	Baza URL
SDK de OpenAI kaj klientoj kongruaj kun OpenAI	`https://api.shannon-ai.com/v1`
SDK de Anthropic	`https://api.shannon-ai.com`

Tri endpoints produktas tekston. Ili atingas la samajn modelojn; elektu tiun, kies formaton via kodo jam uzas.

Ĉuĵuŝpunkto	Formato
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Sendu unuan peton

Sendu unu mesaĝon user al shannon-3 ĉe la endpoint Chat Completions. Anstataŭigu YOUR_API_KEY per via ŝlosilo.

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

Kampo	Tipo	Defaŭlto	Priskribo
`model`	`string`		La id de la modelo, kiu respondas. La id estas listigitaj en Models & pricing.
`messages`	`array`		La konversacio ĝis nun: objektoj kun `role` kaj `content`. La lasta mesaĝo `user` estas la prompt. Deviga.
`max_tokens`	`integer`	`4096`	La eliga buĝeto de la peto, de 1 ĝis 65,536. La peto rezervas ĉi tiun kvanton el via saldo kaj estas kalkulata por tio, kion ĝi vere uzis.
`stream`	`boolean`	`false`	`true` sendas la respondon peceto post peceto dum ĝi estas skribata.

La korpo de la peto estas JSON kaj bezonas la kapon Content-Type: application/json. La plena listo de kampoj estas en la paĝo de la endpoint. Chat Completions

La respondo

Voko sen stream redonas unu JSON-objekton kiam la respondo estas kompleta. La tekstoj kaj nombroj sube estas ekzemploj.

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

Kampo	Tipo	Priskribo
`id`	`string`	`chatcmpl-` sekvata de 32 deksesumaj signoj.
`object`	`string`	Ĉiam `chat.completion`.
`created`	`integer`	La tempo de la respondo en Unix-sekundoj.
`model`	`string`	La publikigita id de la modelo, kiu respondis, ankaŭ kiam vi sendis alias aŭ alian literumon.
`choices`	`array`	Ĉiam unu ero, kun `index` 0.
`choices[0].message.role`	`string`	Ĉiam `assistant`.
`choices[0].message.content`	`string \| null`	La respondo. Ĝi povas esti `null` kiam la respondo portas `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	La rezonado de la modelo antaŭ ĝia respondo, aŭ `null` kiam ne ekzistas.
`choices[0].message.tool_calls`	`array`	Ĉeestas nur kiam la modelo vokas unu el la iloj, kiujn vi deklaris.
`choices[0].finish_reason`	`string`	`stop` por respondo, `tool_calls` kiam la modelo vokas ilon.
`usage.prompt_tokens`	`integer`	La tokenoj, kiujn la modelo legis por ĉi tiu respondo. Ĉe `shannon-2-*` kaj la familio Shannon 3 tio povas esti pli ol la teksto, kiun vi sendis.
`usage.completion_tokens`	`integer`	La tokenoj, kiujn la modelo skribis.
`usage.total_tokens`	`integer`	La sumo. La kosto de Shannon-modelo estas kalkulata el ĉi tiu nombro.

usage enhavas nombrojn de tokenoj, ne monon. Kion la voko prenis el via saldo, estas montrata por peto en Keys & usage; kiel ĝi estas kalkulata, estas en Limoj kaj saldo. Limoj kaj saldo
Ĉiu respondo, ankaŭ eraro kaj fluo, havas la kapon x-request-id. Se via peto portas kapon x-request-id, ĝia valoro revenas; alie la valoro estas 12 deksesumaj signoj. Konservu ĝin en viaj protokoloj: ĝi nomas ĉi tiun unu peton.

La sama voko kiel fluo

Agordu stream al true por legi la respondon dum ĝi estas skribata. Ĉio alia en la peto restas sama.

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

Ĉiu kadro de la fluo estas unu linio, kiu komenciĝas per data: kaj enhavas JSON-objekton. Unu kadro, presita sur pluraj linioj:

Unu kadro

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

Kadroj, laŭorde	delta	finish_reason
Dum la modelo rezonas. Nul aŭ pli da kadroj.	`{"reasoning_content": "…"}`	`null`
La respondo, peceto post peceto. Nul aŭ pli da kadroj.	`{"content": "…"}`	`null`
La lasta JSON-kadro. Ĝi portas ankaŭ `usage`; vi ne devas peti ĝin.	`{}`	`"stop"`
La fino de la fluo: la linio `data: [DONE]`.

La respondo havas staton 200 kaj content-type: text/event-stream. Ĉiu kadro estas linio data: <json> sekvata de malplena linio.
Linio : ping alvenas ĉiujn 15 sekundojn. Ĝi estas komento, kiu tenas la konekton malfermita; klientoj de SSE preterpasas ĝin.
Malsukceso post la malfermo de la fluo alvenas kiel kadro data: {"error": {…}}. La stato restas 200, do kontrolu la kadrojn.

Fluigo

Se la voko malsukcesas

Eraro estas JSON-objekto kun error, kiu enhavas type kaj message. Jen la respondoj, kiujn unua voko plej ofte renkontas.

Stato	Tipo	Mesaĝo	Kion ĝi signifas
`401`	`authentication_error`	`Missing authentication`	Neniu ŝlosilo atingis la API. Sendu `Authorization: Bearer` sekvata de via ŝlosilo.
`401`	`authentication_error`	`Invalid API key`	La ŝlosilo ne estas la nuna ŝlosilo de konto. Kopiu ĝin denove el Keys & usage.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` ne estas publikigita id. Uzu id el Models & pricing.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Kampo havas malĝustan JSON-tipon, aŭ `messages` mankas.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	La eliga buĝeto de la peto ne eniras en vian saldon.

Erarotraktado

Kien iri poste

Modeloj kaj prezoj — Elektu modelon: id, kuntekstaj fenestroj kaj prezoj.
Chat Completions — Ĉiu kampo de peto, kampo de respondo kaj evento de fluo de la endpoint, kiun vi vokis.
Fluigo — La kadroj de fluo, linioj keep-alive kaj eraroj en fluo.
Funkci-alvokoj — Lasu la modelon voki viajn funkciojn.
Limoj kaj saldo — Kion peto rezervas kaj kostas, kaj kiom da petoj vi rajtas sendi.
API Ludejo — Provu petojn en la retumilo kun via ŝlosilo.