Ibẹrẹ kiakia

Ṣe ìbéèrè àkọ́kọ́: gba key rẹ, fi ìfiránṣẹ́ kan ránṣẹ́ kí o sì ka èsì náà. API ń sọ àwọn ọ̀nà OpenAI àti Anthropic, nítorí náà SDK tí o ti ń lò ń ṣiṣẹ́ lẹ́yìn tí o bá yí base URL àti key rẹ̀ padà.

1. Gba key rẹ

Account kọ̀ọ̀kan ní API key kan. Wọlé, ṣí Àwọn key àti ìlò kí o sì daakọ rẹ̀. Key náà ń ṣiṣẹ́ lórí gbogbo endpoint àti gbogbo model. Àwọn key àti ìlò

2. Darí client rẹ sí API

Gbogbo endpoint wà lábẹ́ base URL kan. SDK OpenAI ń gbà á pẹ̀lú /v1 ní ìparí; SDK Anthropic ń gbà á láìsí i, nítorí ó fúnra rẹ̀ ń fi /v1/messages kún un.

Client	Base URL
Àwọn SDK OpenAI àti àwọn client tó bá OpenAI mu	`https://api.shannon-ai.com/v1`
Àwọn SDK Anthropic	`https://api.shannon-ai.com`

Endpoint mẹ́ta ń mú ọ̀rọ̀ jáde. Wọ́n ń dé àwọn model kan náà; yan èyí tí code rẹ ti ń lo ọ̀nà rẹ̀.

Endpoint	Ọ̀nà
`POST /v1/chat/completions`	OpenAI Chat Completions
`POST /v1/messages`	Anthropic Messages
`POST /v1/responses`	OpenAI Responses

3. Fi ìbéèrè àkọ́kọ́ ránṣẹ́

Fi ìfiránṣẹ́ user kan ránṣẹ́ sí shannon-3 lórí endpoint Chat Completions. Rọ́pò YOUR_API_KEY pẹ̀lú key rẹ.

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	Irú	Default	Àpèjúwe
`model`	`string`		Id model tó ń dáhùn. A ṣàkójọ àwọn id lórí Àwọn model àti iye owó.
`messages`	`array`		Ìjíròrò títí di báyìí: àwọn object pẹ̀lú `role` àti `content`. Ìfiránṣẹ́ `user` tó gbẹ̀yìn ni prompt. Dandan.
`max_tokens`	`integer`	`4096`	Iye output ìbéèrè náà, láti 1 dé 65,536. Ìbéèrè náà ń fi iye yìí pamọ́ láti balance rẹ, a sì ń gba owó ohun tó lò nítòótọ́.
`stream`	`boolean`	`false`	`true` ń fi ìdáhùn ránṣẹ́ díẹ̀díẹ̀ bí a ṣe ń kọ ọ́.

Body ìbéèrè jẹ́ JSON, ó sì nílò header Content-Type: application/json. Àtòjọ kíkún àwọn field wà lórí ojú-ìwé endpoint. Chat Completions

Èsì náà

Ìpè láìsí stream ń dá object JSON kan padà nígbà tí ìdáhùn bá pé. Àwọn ọ̀rọ̀ àti nọ́ńbà ìsàlẹ̀ jẹ́ àpẹẹrẹ.

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	Irú	Àpèjúwe
`id`	`string`	`chatcmpl-` tí àwọn ọ̀rọ̀ hexadecimal 32 tẹ̀lé.
`object`	`string`	Nígbà gbogbo `chat.completion`.
`created`	`integer`	Àkókò èsì ní ìṣẹ́jú-àáyá Unix.
`model`	`string`	Id tí a tẹ̀ jáde ti model tó dáhùn, kódà nígbà tí o bá fi alias tàbí ìkọ̀wé mìíràn ránṣẹ́.
`choices`	`array`	Ìkọ̀sílẹ̀ kan ṣoṣo nígbà gbogbo, pẹ̀lú `index` 0.
`choices[0].message.role`	`string`	Nígbà gbogbo `assistant`.
`choices[0].message.content`	`string \| null`	Ìdáhùn náà. Ó lè jẹ́ `null` nígbà tí èsì bá gbé `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	Ìrònú model ṣáájú ìdáhùn rẹ̀, tàbí `null` nígbà tí kò bá sí.
`choices[0].message.tool_calls`	`array`	Ó wà nígbà tí model bá pe ọ̀kan nínú àwọn tool tí o kéde nìkan.
`choices[0].finish_reason`	`string`	`stop` fún ìdáhùn, `tool_calls` nígbà tí model bá pe tool.
`usage.prompt_tokens`	`integer`	Àwọn token tí model kà fún ìdáhùn yìí. Lórí `shannon-2-*` àti ìdílé Shannon 3, èyí lè pọ̀ ju ọ̀rọ̀ tí o fi ránṣẹ́.
`usage.completion_tokens`	`integer`	Àwọn token tí model kọ.
`usage.total_tokens`	`integer`	Àròpọ̀. A ń ṣírò owó model Shannon láti nọ́ńbà yìí.

usage ní iye token, kì í ṣe owó. Ohun tí ìpè gba láti balance rẹ ni a fi hàn fún ìbéèrè kọ̀ọ̀kan lórí Àwọn key àti ìlò; bí a ṣe ń ṣírò rẹ̀ wà lórí Àwọn ààlà àti balance. Àwọn ààlà àti balance
Gbogbo èsì, pẹ̀lú àṣìṣe àti stream, ní header x-request-id. Tí ìbéèrè rẹ bá gbé header x-request-id, iye rẹ̀ ń padà wá; bí bẹ́ẹ̀ kọ́, iye náà jẹ́ àwọn ọ̀rọ̀ hexadecimal 12. Pa á mọ́ nínú àwọn log rẹ: ó ń dárúkọ ìbéèrè kan ṣoṣo yìí.

Ìpè kan náà bí stream

Ṣètò stream sí true láti ka ìdáhùn bí a ṣe ń kọ ọ́. Gbogbo nǹkan mìíràn nínú ìbéèrè ń dúró bákan náà.

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

Frame kọ̀ọ̀kan ti stream jẹ́ ìlà kan tó bẹ̀rẹ̀ pẹ̀lú data: tó sì gbé object JSON mú. Frame kan, tí a tẹ̀ jáde lórí ọ̀pọ̀ ìlà:

Frame kan

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

Àwọn frame, lẹ́sẹẹsẹ	delta	finish_reason
Nígbà tí model ń ronú. Frame òdo tàbí jù bẹ́ẹ̀ lọ.	`{"reasoning_content": "…"}`	`null`
Ìdáhùn náà, díẹ̀díẹ̀. Frame òdo tàbí jù bẹ́ẹ̀ lọ.	`{"content": "…"}`	`null`
Frame JSON tó gbẹ̀yìn. Ó tún gbé `usage`; o kò nílò láti béèrè fún un.	`{}`	`"stop"`
Òpin stream: ìlà `data: [DONE]`.

Èsì ní status 200 àti content-type: text/event-stream. Frame kọ̀ọ̀kan jẹ́ ìlà data: <json> tí ìlà òfo tẹ̀lé.
Ìlà : ping ń dé ní ìṣẹ́jú-àáyá 15 kọ̀ọ̀kan. Ó jẹ́ ọ̀rọ̀ ìṣàlàyé tó ń jẹ́ kí asopọ̀ ṣí; àwọn client SSE ń fò ó.
Ìkùnà lẹ́yìn tí stream ti ṣí ń dé bí frame data: {"error": {…}}. Status ń wà 200, nítorí náà ṣàyẹ̀wò àwọn frame.

Sisanwọle

Tí ìpè náà bá kùnà

Àṣìṣe jẹ́ object JSON pẹ̀lú error tó ní type àti message. Wọ̀nyí ni àwọn èsì tí ìpè àkọ́kọ́ máa ń bá pàdé jù.

Ipò	Irú	Ìfiránṣẹ́	Ohun tó túmọ̀ sí
`401`	`authentication_error`	`Missing authentication`	Kò sí key tó dé API. Fi `Authorization: Bearer` tí key rẹ tẹ̀lé ránṣẹ́.
`401`	`authentication_error`	`Invalid API key`	Key kì í ṣe key lọ́wọ́lọ́wọ́ ti account kan. Daakọ rẹ̀ lẹ́ẹ̀kan sí i láti Àwọn key àti ìlò.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` kì í ṣe id tí a tẹ̀ jáde. Lo id láti Àwọn model àti iye owó.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Field ní irú JSON tí kò tọ̀, tàbí `messages` kò sí.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	Iye output ìbéèrè náà kò wọ inú balance rẹ.

Mimu Aṣiṣe

Ibi tí a ó lọ tẹ̀lé

Àwọn model àti iye owó — Yan model: àwọn id, context window àti iye owó.
Chat Completions — Gbogbo field ìbéèrè, field èsì àti event stream ti endpoint tí o pè.
Sisanwọle — Àwọn frame stream, àwọn ìlà keep-alive àti àwọn àṣìṣe inú stream.
Ipe iṣẹ — Jẹ́ kí model pe àwọn function rẹ.
Àwọn ààlà àti balance — Ohun tí ìbéèrè ń fi pamọ́ tó sì ń ná, àti iye ìbéèrè tí o lè fi ránṣẹ́.
API ibi isereile — Gbìyànjú àwọn ìbéèrè nínú browser pẹ̀lú key rẹ.