Mabilis na Pagsisimula

Gumawa ng unang request: kunin ang iyong key, magpadala ng isang message at basahin ang reply. Sinasalita ng API ang mga format ng OpenAI at Anthropic, kaya gumagana ang SDK na ginagamit mo na pagkatapos mong palitan ang base URL at key nito.

1. Kunin ang iyong key

Bawat account ay may isang API key. Mag-sign in, buksan ang Keys & usage at kopyahin ito. Gumagana ang key sa bawat endpoint at bawat model. Keys & usage

2. Ituro ang iyong client sa API

Nasa ilalim ng iisang base URL ang lahat ng endpoint. Tinatanggap ito ng OpenAI SDK na may /v1 sa dulo; tinatanggap ito ng Anthropic SDK nang wala, dahil idinaragdag nito mismo ang /v1/messages.

Client	Base URL
Mga OpenAI SDK at client na compatible sa OpenAI	`https://api.shannon-ai.com/v1`
Mga Anthropic SDK	`https://api.shannon-ai.com`

Tatlong endpoint ang gumagawa ng text. Naaabot nila ang parehong mga model; piliin ang may format na ginagamit na ng iyong code.

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

3. Magpadala ng unang request

Magpadala ng isang user message sa shannon-3 sa Chat Completions endpoint. Palitan ang YOUR_API_KEY ng iyong key.

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

Field	Type	Default	Paglalarawan
`model`	`string`		Ang id ng model na sasagot. Nakalista ang mga id sa Mga model at presyo.
`messages`	`array`		Ang conversation hanggang ngayon: mga object na may `role` at `content`. Ang huling `user` message ang prompt. Kinakailangan.
`max_tokens`	`integer`	`4096`	Ang output budget ng request, mula 1 hanggang 65,536. Itinatabi ng request ang halagang ito mula sa iyong balance at sinisingil para sa aktuwal nitong nagamit.
`stream`	`boolean`	`false`	Ipinapadala ng `true` ang sagot nang pira-piraso habang isinusulat ito.

JSON ang request body at kailangan nito ang header na Content-Type: application/json. Nasa pahina ng endpoint ang buong listahan ng mga field. Chat Completions

Ang reply

Ang call na walang stream ay nagbabalik ng isang JSON object kapag kumpleto na ang sagot. Mga halimbawa ang mga text at numero sa ibaba.

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

Field	Type	Paglalarawan
`id`	`string`	`chatcmpl-` na sinusundan ng 32 hexadecimal na character.
`object`	`string`	Palaging `chat.completion`.
`created`	`integer`	Ang oras ng reply sa Unix seconds.
`model`	`string`	Ang inilathalang id ng model na sumagot, kahit nagpadala ka ng alias o ibang baybay.
`choices`	`array`	Palaging isang entry, na may `index` 0.
`choices[0].message.role`	`string`	Palaging `assistant`.
`choices[0].message.content`	`string \| null`	Ang sagot. Maaari itong maging `null` kapag may dalang `tool_calls` ang reply.
`choices[0].message.reasoning_content`	`string \| null`	Ang reasoning ng model bago ang sagot nito, o `null` kapag wala.
`choices[0].message.tool_calls`	`array`	Naroroon lamang kapag tumawag ang model ng isa sa mga tool na idineklara mo.
`choices[0].finish_reason`	`string`	`stop` para sa sagot, `tool_calls` kapag tumatawag ng tool ang model.
`usage.prompt_tokens`	`integer`	Ang mga token na binasa ng model para sa sagot na ito. Sa `shannon-2-*` at pamilyang Shannon 3, maaari itong mas marami kaysa sa text na ipinadala mo.
`usage.completion_tokens`	`integer`	Ang mga token na isinulat ng model.
`usage.total_tokens`	`integer`	Ang kabuuan. Kinukuwenta mula sa numerong ito ang singil ng Shannon model.

Ang usage ay may bilang ng token, hindi pera. Ang kinuha ng call mula sa iyong balance ay ipinapakita kada request sa Keys & usage; kung paano ito kinukuwenta ay nasa Mga limitasyon at balance. Mga limitasyon at balance
Bawat reply, pati error at stream, ay may header na x-request-id. Kung may dalang x-request-id header ang request mo, bumabalik ang value nito; kung hindi, ang value ay 12 hexadecimal na character. Itago ito sa iyong mga log: pinangangalanan nito ang isang request na ito.

Ang parehong call bilang stream

I-set ang stream sa true para basahin ang sagot habang isinusulat ito. Ang lahat ng iba pa sa request ay nananatiling pareho.

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

Ang bawat frame ng stream ay isang linyang nagsisimula sa data: at may hawak na JSON object. Isang frame, na naka-print sa maraming linya:

Isang frame

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

Mga frame, ayon sa pagkakasunod	delta	finish_reason
Habang nag-re-reason ang model. Zero o higit pang frame.	`{"reasoning_content": "…"}`	`null`
Ang sagot, pira-piraso. Zero o higit pang frame.	`{"content": "…"}`	`null`
Ang huling JSON frame. May dala rin itong `usage`; hindi mo na kailangang hilingin ito.	`{}`	`"stop"`
Ang wakas ng stream: ang linyang `data: [DONE]`.

Ang reply ay may status na 200 at content-type: text/event-stream. Ang bawat frame ay isang linyang data: <json> na sinusundan ng walang lamang linya.
Dumarating ang linyang : ping tuwing 15 segundo. Isa itong comment na nagpapanatiling bukas sa koneksyon; nilalaktawan ito ng mga SSE client.
Ang pagkabigo pagkatapos magbukas ang stream ay dumarating bilang frame na data: {"error": {…}}. Nananatiling 200 ang status, kaya suriin ang mga frame.

Pag‑stream

Kung mabigo ang call

Ang error ay isang JSON object na may error na naglalaman ng type at message. Ito ang mga reply na pinakamadalas masalubong ng unang call.

Status	Type	Mensahe	Ano ang ibig sabihin
`401`	`authentication_error`	`Missing authentication`	Walang key na nakarating sa API. Ipadala ang `Authorization: Bearer` na sinusundan ng iyong key.
`401`	`authentication_error`	`Invalid API key`	Hindi ang kasalukuyang key ng isang account ang key. Kopyahin muli mula sa Keys & usage.
`400`	`invalid_request_error`	`unknown model: <id>`	Hindi inilathalang id ang `model`. Gumamit ng id mula sa Mga model at presyo.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Mali ang JSON type ng isang field, o nawawala ang `messages`.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Hindi kasya sa iyong balance ang output budget ng request.

Paghawak ng Error

Saan susunod pupunta

Mga model at presyo — Pumili ng model: mga id, context window at presyo.
Chat Completions — Bawat request field, reply field at stream event ng endpoint na tinawag mo.
Pag‑stream — Ang mga frame ng stream, keep-alive line at mga error sa loob ng stream.
Function calling — Hayaang tawagin ng model ang iyong mga function.
Mga limitasyon at balance — Ano ang itinatabi at nagagastos ng request, at ilang request ang maaari mong ipadala.
Playground ng API — Subukan ang mga request sa browser gamit ang iyong key.