Initium celer

Fac primam petitionem: accipe clavem tuam, mitte unum nuntium et lege responsionem. API formas OpenAI et Anthropic loquitur, itaque SDK quo iam uteris operatur postquam base URL et clavem eius mutas.

1. Accipe clavem tuam

Quaeque ratio unam clavem API habet. Ingredere, aperi Keys & usage et copia eam. Clavis in omni endpoint et omni modello operatur. Claves et usus

2. Dirige clientem tuum ad API

Omnia endpoints sub uno base URL sunt. SDK OpenAI eum cum /v1 in fine accipit; SDK Anthropic eum sine accipit, quia ipse /v1/messages addit.

Cliens	Base URL
SDK OpenAI et clientes OpenAI-compatibiles	`https://api.shannon-ai.com/v1`
SDK Anthropic	`https://api.shannon-ai.com`

Tria endpoints textum producunt. Ad eadem modelli perveniunt; elige illud cuius formam codex tuus iam utitur.

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

3. Mitte primam petitionem

Mitte unum nuntium user ad shannon-3 in endpoint Chat Completions. Substitue YOUR_API_KEY clave tua.

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

Campus	Genus	Default	Descriptio
`model`	`string`		Id modelli quod respondet. Ids in Models & pricing enumerantur.
`messages`	`array`		Conversatio hactenus: objecta cum `role` et `content`. Ultimus nuntius `user` est prompt. Necessarium.
`max_tokens`	`integer`	`4096`	Budget outputi petitionis, ab 1 ad 65,536. Petitio hanc quantitatem de saldo tuo reservat et pro eo quod vere usa est computatur.
`stream`	`boolean`	`false`	`true` responsionem frustatim mittit dum scribitur.

Corpus petitionis est JSON et header Content-Type: application/json requirit. Index plenus camporum in pagina endpoint est. Chat Completions

Responsio

Vocatio sine stream unum objectum JSON reddit cum responsio completa est. Textus et numeri infra exempla sunt.

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

Campus	Genus	Descriptio
`id`	`string`	`chatcmpl-` quod 32 notae hexadecimales sequuntur.
`object`	`string`	Semper `chat.completion`.
`created`	`integer`	Tempus responsionis in secundis Unix.
`model`	`string`	Id publicatum modelli quod respondit, etiam cum alias aut aliam scripturam misisti.
`choices`	`array`	Semper una inscriptio, cum `index` 0.
`choices[0].message.role`	`string`	Semper `assistant`.
`choices[0].message.content`	`string \| null`	Responsio. Esse potest `null` cum responsio `tool_calls` fert.
`choices[0].message.reasoning_content`	`string \| null`	Ratiocinatio modelli ante responsionem suam, aut `null` cum nulla est.
`choices[0].message.tool_calls`	`array`	Adest tantum cum modellum unum e tools quae declaravisti vocat.
`choices[0].finish_reason`	`string`	`stop` pro responsione, `tool_calls` cum modellum tool vocat.
`usage.prompt_tokens`	`integer`	Tokens quos modellum pro hac responsione legit. In `shannon-2-*` et familia Shannon 3 hoc plus esse potest quam textus quem misisti.
`usage.completion_tokens`	`integer`	Tokens quos modellum scripsit.
`usage.total_tokens`	`integer`	Summa. Pretium modelli Shannon ex hoc numero computatur.

usage numeros tokenum tenet, non pecuniam. Quid vocatio de saldo tuo traxerit per petitionem in Keys & usage ostenditur; quomodo computetur in Limits and balance est. Limites et saldum
Omnis responsio, etiam error et stream, header x-request-id habet. Si petitio tua header x-request-id fert, valor eius redit; alioquin valor est 12 notae hexadecimales. Serva eum in logs tuis: hanc unam petitionem nominat.

Eadem vocatio ut stream

Pone stream ad true ut responsionem legas dum scribitur. Omnia alia in petitione eadem manent.

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

Quisque frame streami est una linea quae cum data: incipit et objectum JSON tenet. Unus frame, in pluribus lineis impressus:

Unus frame

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

Frames, in ordine	delta	finish_reason
Dum modellum ratiocinatur. Nulli vel plures frames.	`{"reasoning_content": "…"}`	`null`
Responsio, frustatim. Nulli vel plures frames.	`{"content": "…"}`	`null`
Ultimus frame JSON. Etiam `usage` fert; eum petere non debes.	`{}`	`"stop"`
Finis streami: linea `data: [DONE]`.

Responsio statum 200 et content-type: text/event-stream habet. Quisque frame est linea data: <json> quam linea vacua sequitur.
Linea : ping omnibus 15 secundis advenit. Est commentarium quod connexionem apertam servat; clientes SSE eam praetereunt.
Defectus postquam stream apertus est ut frame data: {"error": {…}} advenit. Status manet 200, itaque frames inspice.

Fluens

Si vocatio deficit

Error est objectum JSON cum error quod type et message tenet. Hae sunt responsiones quas prima vocatio saepissime invenit.

Status	Genus	Nuntius	Quid significet
`401`	`authentication_error`	`Missing authentication`	Nulla clavis ad API pervenit. Mitte `Authorization: Bearer` quod clavis tua sequitur.
`401`	`authentication_error`	`Invalid API key`	Clavis non est clavis currens rationis. Copia eam iterum ex Keys & usage.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` non est id publicatum. Utere id ex Models & pricing.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Campus typum JSON falsum habet, aut `messages` deest.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Budget outputi petitionis in saldum tuum non capitur.

Tractatio errorum

Quo deinde eas

Modella et pretia — Elige modellum: ids, context windows et pretia.
Chat Completions — Omnis campus petitionis, campus responsionis et eventus stream endpoint quod vocasti.
Fluens — Frames streami, lineae keep-alive et errores intra stream.
Vocatio functionum — Permitte modello functiones tuas vocare.
Limites et saldum — Quid petitio reservet et quanti constet, et quot petitiones mittere possis.
Locus API — Tenta petitiones in navigatore cum clave tua.