Inicio rápido

Fai unha primeira solicitude: obtén a túa clave, envía unha mensaxe e le a resposta. A API fala os formatos de OpenAI e Anthropic, así que o SDK que xa usas funciona despois de cambiar a súa URL base e a clave.

1. Obtén a túa clave

Cada conta ten unha clave API. Inicia sesión, abre Claves e uso e cópiaa. A clave funciona en todos os endpoints e todos os modelos. Claves e uso

2. Apunta o teu cliente á API

Todos os endpoints están baixo unha URL base. Un SDK de OpenAI recíbea con /v1 ao final; un SDK de Anthropic recíbea sen el, porque engade /v1/messages por si mesmo.

Cliente	URL base
SDK de OpenAI e clientes compatibles con OpenAI	`https://api.shannon-ai.com/v1`
SDK de Anthropic	`https://api.shannon-ai.com`

Tres endpoints producen texto. Chegan aos mesmos modelos; escolle aquel cuxo formato xa usa o teu código.

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

3. Envía unha primeira solicitude

Envía unha mensaxe user a shannon-3 no endpoint Chat Completions. Substitúe YOUR_API_KEY pola túa clave.

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

Campo	Tipo	Valor predeterminado	Descrición
`model`	`string`		O id do modelo que responde. Os ids están listados en Modelos e prezos.
`messages`	`array`		A conversa ata agora: obxectos con `role` e `content`. A última mensaxe `user` é o prompt. Obrigatorio.
`max_tokens`	`integer`	`4096`	O orzamento de saída da solicitude, de 1 a 65,536. A solicitude reserva esta cantidade do teu saldo e cóbrase polo que realmente usou.
`stream`	`boolean`	`false`	`true` envía a resposta anaco a anaco mentres se escribe.

O corpo da solicitude é JSON e necesita a cabeceira Content-Type: application/json. A lista completa de campos está na páxina do endpoint. Chat Completions

A resposta

Unha chamada sen stream devolve un obxecto JSON cando a resposta está completa. Os textos e números de abaixo son exemplos.

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

Campo	Tipo	Descrición
`id`	`string`	`chatcmpl-` seguido de 32 caracteres hexadecimais.
`object`	`string`	Sempre `chat.completion`.
`created`	`integer`	A hora da resposta en segundos Unix.
`model`	`string`	O id publicado do modelo que respondeu, tamén cando enviaches un alias ou outra grafía.
`choices`	`array`	Sempre unha entrada, con `index` 0.
`choices[0].message.role`	`string`	Sempre `assistant`.
`choices[0].message.content`	`string \| null`	A resposta. Pode ser `null` cando a resposta leva `tool_calls`.
`choices[0].message.reasoning_content`	`string \| null`	O razoamento do modelo antes da súa resposta, ou `null` cando non hai ningún.
`choices[0].message.tool_calls`	`array`	Só está presente cando o modelo chama a unha das ferramentas que declaraches.
`choices[0].finish_reason`	`string`	`stop` para unha resposta, `tool_calls` cando o modelo chama a unha ferramenta.
`usage.prompt_tokens`	`integer`	Os tokens que leu o modelo para esta resposta. En `shannon-2-*` e na familia Shannon 3 pode ser máis que o texto que enviaches.
`usage.completion_tokens`	`integer`	Os tokens que escribiu o modelo.
`usage.total_tokens`	`integer`	O total. O custo dun modelo Shannon calcúlase a partir deste número.

usage contén recontos de tokens, non diñeiro. O que tomou a chamada do teu saldo móstrase por solicitude en Claves e uso; como se calcula está en Límites e saldo. Límites e saldo
Todas as respostas, tamén un erro e un stream, teñen a cabeceira x-request-id. Se a túa solicitude leva unha cabeceira x-request-id, devólvese o seu valor; se non, o valor son 12 caracteres hexadecimais. Gárdao nos teus rexistros: identifica esta solicitude concreta.

A mesma chamada como stream

Define stream como true para ler a resposta mentres se escribe. Todo o demais na solicitude queda igual.

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

Cada frame do stream é unha liña que comeza por data: e contén un obxecto JSON. Un frame, impreso en varias liñas:

Un frame

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

Frames, por orde	delta	finish_reason
Mentres o modelo razoa. Cero ou máis frames.	`{"reasoning_content": "…"}`	`null`
A resposta, anaco a anaco. Cero ou máis frames.	`{"content": "…"}`	`null`
O último frame JSON. Tamén leva `usage`; non fai falta pedilo.	`{}`	`"stop"`
O final do stream: a liña `data: [DONE]`.

A resposta ten o estado 200 e content-type: text/event-stream. Cada frame é unha liña data: <json> seguida dunha liña baleira.
Cada 15 segundos chega unha liña : ping. É un comentario que mantén a conexión aberta; os clientes SSE sáltano.
Un fallo despois de abrirse o stream chega como un frame data: {"error": {…}}. O estado segue sendo 200, así que comproba os frames.

Streaming

Se a chamada falla

Un erro é un obxecto JSON cun error que contén type e message. Estas son as respostas que atopa con máis frecuencia unha primeira chamada.

Estado	Tipo	Mensaxe	Que significa
`401`	`authentication_error`	`Missing authentication`	Ningunha clave chegou á API. Envía `Authorization: Bearer` seguido da túa clave.
`401`	`authentication_error`	`Invalid API key`	A clave non é a clave actual dunha conta. Cópiaa de novo desde Claves e uso.
`400`	`invalid_request_error`	`unknown model: <id>`	`model` non é un id publicado. Usa un id de Modelos e prezos.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type…`	Un campo ten o tipo JSON incorrecto, ou falta `messages`.
`429`	`rate_limit_error`	`Quota exceeded. Upgrade your plan at shannon-ai.com/plan`	O orzamento de saída da solicitude non cabe no teu saldo.

Xestión de erros

Onde ir despois

Modelos e prezos — Escolle un modelo: ids, ventás de contexto e prezos.
Chat Completions — Todos os campos de solicitude, campos de resposta e eventos de stream do endpoint ao que chamaches.
Streaming — Os frames dun stream, as liñas keep-alive e os erros dentro dun stream.
Chamadas a funcións — Deixa que o modelo chame ás túas funcións.
Límites e saldo — O que reserva e custa unha solicitude, e cantas solicitudes podes enviar.
Playground da API — Proba solicitudes no navegador coa túa clave.