Documentación da API de Shannon AI

Visión xeral

Documentacion publica

Todo o que precisas para lanzar coa API compatible con OpenAI e Anthropic de Shannon.

URL base Compatible con OpenAI

https://api.shannon-ai.com/v1/chat/completions

Usa a API de Chat Completions con chamada de funcions e streaming.

URL base Compatible con Anthropic

https://api.shannon-ai.com/v1/messages

Formato Claude Messages con ferramentas e cabeceira anthropic-version.

Cabeceiras Autenticación

Authorization: Bearer <api-key>

Ou X-API-Key con anthropic-version para chamadas estilo Claude.

Acceso Estado

Documentacion publica - Requrese chave para chamar

Streaming, chamada de funcions, saidas estruturadas, busca web.

Lista de comprobacion de lanzamento

+

Apunta o teu SDK a Shannon

Establece baseURL nos endpoints de OpenAI ou Anthropic anteriores.

Configuracion
+

Engade a tua chave API

Usa tokens Bearer para chamadas OpenAI ou X-API-Key + anthropic-version.

Seguridade
+

Activa ferramentas e saidas estruturadas

Admite ferramentas/funcions de OpenAI, esquema JSON e web_search integrado.

Capacidades
+

Rastrexar uso

Consulta o consumo de tokens e buscas nesta paxina cando inicias sesion na tua conta.

Analitica

Capacidades

OpenAI + Anthropic

Substituto directo de OpenAI e Anthropic con soporte nativo para ferramentas, saídas estruturadas e busca web integrada.

Substitución drop‑in

Compatible

Funciona cos SDK de OpenAI e Anthropic. Só tes que cambiar o URL base.

Chamada de funcións

Ferramentas

Define ferramentas, deixa que Shannon as chame. Admite modos auto, forced e none.

Busca web integrada

Busca

Busca web en tempo real con citas de fontes. Dispoñible automaticamente.

Saídas estruturadas

JSON

Modo JSON e aplicación de JSON Schema para extracción fiable de datos.

Ferramentas multivolta

Axente

Bucles de execución automática de funcións. Ata 10 iteracións por solicitude.

Streaming

Rápido

Eventos enviados polo servidor para streaming de tokens en tempo real.

Inicio rápido

5 minutos

Comeza en tres pasos. Shannon imita os clientes de OpenAI e Anthropic.

Define o URL base

Emprega o endpoint compatible con OpenAI.

https://api.shannon-ai.com/v1/chat/completions

Engade a túa clave API

Usa autenticación Bearer na cabeceira Authorization.

Envía a túa primeira mensaxe

Escolle unha lingua e substitúe a túa clave.

Python

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-1.6-lite",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, Shannon!"}
    ],
    max_tokens=1024
)

print(response.choices[0].message.content)

JavaScript

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-1.6-lite',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { 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-1.6-lite",
            Messages: []openai.ChatCompletionMessage{
                {Role: "system", Content: "You are a helpful assistant."},
                {Role: "user", Content: "Hello, Shannon!"},
            },
            MaxTokens: 1024,
        },
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

cURL

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-1.6-lite",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello, Shannon!"}
    ],
    "max_tokens": 1024
  }'

Formato da resposta

Resposta satisfactoria

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1234567890,
  "model": "Shannon 1.6 Lite",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! I'm Shannon, your AI assistant. How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 25,
    "completion_tokens": 18,
    "total_tokens": 43
  }
}

Playground da API

Novo

Proba a API de Shannon directamente no navegador. Crea a solicitude, execútaa e ve a resposta en tempo real.

Chat, Responses, Messages

Switch across OpenAI Chat Completions, Responses, and Anthropic Messages without leaving the playground.

Stream live output

Run real requests, inspect raw JSON, and view stream events from the same operator console.

Reuse your key

Signed-in users can pull their Shannon API key straight into the dedicated playground workspace.

/gl/docs/playground

The playground now lives on its own route so the API docs stay Astro-rendered while the request builder remains an explicitly interactive client tool.

Proba o Playground V2 Obtén a túa clave API

Autenticación

Todas as solicitudes API requiren autenticación usando a túa clave API de Shannon.

Formato OpenAI (Recomendado)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic

HTTP

X-API-Key: YOUR_API_KEY
anthropic-version: 2023-06-01

Modelos

Shannon ofrece varios modelos optimizados para diferentes casos de uso.

shannon-1.6-lite Shannon 1.6 Lite

Respostas rapidas e eficientes para tarefas cotians

Contexto 128K

Ideal para Chat, Q&A, xeracion de contido

shannon-1.6-pro Shannon 1.6 Pro

Razoamento avanzado para problemas complexos

Contexto 128K

Ideal para Analise, investigacion, tarefas complexas

shannon-2-lite Shannon 2 Lite

Contexto 128K

Ideal para

shannon-2-pro Shannon 2 Pro

Contexto 128K

Ideal para

shannon-coder-1 Shannon Coder

Optimizado para Claude Code CLI con cota por chamadas

Contexto 128K

Ideal para Xeracion de codigo, uso de ferramentas, integracion CLI

Cota por chamadas

Chamadas a funcións

Define ferramentas que Shannon pode chamar para executar accións ou recuperar información.

Python

from openai import OpenAI
import json

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

# Define available tools/functions
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City name, e.g., 'Tokyo'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
    tool_choice="auto"
)

# Check if model wants to call a function
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    print(f"Function: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")

JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

const tools = [
  {
    type: 'function',
    function: {
      name: 'get_weather',
      description: 'Get current weather for a location',
      parameters: {
        type: 'object',
        properties: {
          location: { type: 'string', description: "City name" },
          unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
        },
        required: ['location']
      }
    }
  }
];

const response = await client.chat.completions.create({
  model: 'shannon-1.6-lite',
  messages: [{ role: 'user', content: "What's the weather in Tokyo?" }],
  tools,
  tool_choice: 'auto'
});

if (response.choices[0].message.tool_calls) {
  const toolCall = response.choices[0].message.tool_calls[0];
  console.log('Function:', toolCall.function.name);
  console.log('Arguments:', toolCall.function.arguments);
}

Opcions de seleccion de ferramentas

"auto" O modelo decide se chamar unha funcion (por defecto)

"none" Desactiva a chamada de funcions para esta solicitude

{"type": "function", "function": {"name": "..."}} Forza unha chamada de funcion especifica

Resposta de chamada de funcion

Cando o modelo chama unha funcion

{
  "id": "chatcmpl-xyz",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"location\": \"Tokyo\", \"unit\": \"celsius\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ]
}

Saídas estruturadas

Forza a Shannon a responder con JSON válido que coincida co teu esquema.

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

# Force JSON output with schema
response = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[
        {"role": "user", "content": "Extract: John Doe, 30 years old, engineer"}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person_info",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "occupation": {"type": "string"}
                },
                "required": ["name", "age", "occupation"]
            }
        }
    }
)

import json
data = json.loads(response.choices[0].message.content)
print(data)  # {"name": "John Doe", "age": 30, "occupation": "engineer"}

JavaScript

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-1.6-lite',
  messages: [
    { role: 'user', content: 'Extract: John Doe, 30 years old, engineer' }
  ],
  response_format: {
    type: 'json_schema',
    json_schema: {
      name: 'person_info',
      schema: {
        type: 'object',
        properties: {
          name: { type: 'string' },
          age: { type: 'integer' },
          occupation: { type: 'string' }
        },
        required: ['name', 'age', 'occupation']
      }
    }
  }
});

const data = JSON.parse(response.choices[0].message.content);
console.log(data); // { name: "John Doe", age: 30, occupation: "engineer" }

Opcions de formato de resposta

{"type": "json_object"} Forza unha saida JSON valida (sen esquema especifico)

{"type": "json_schema", "json_schema": {...}} Forza unha saida que coincida co teu esquema exacto

Streaming

Activa o streaming de tokens en tempo real con Server‑Sent Events para UIs responsivas.

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

# Enable streaming for real-time responses
stream = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[
        {"role": "user", "content": "Write a short poem about AI"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

// Enable streaming for real-time responses
const stream = await client.chat.completions.create({
  model: 'shannon-1.6-lite',
  messages: [
    { role: 'user', content: 'Write a short poem about AI' }
  ],
  stream: true
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

Consello: As respostas en streaming chegan como Server-Sent Events. Cada bloque contan un delta con contido parcial.

Busca web

Shannon inclúe unha función web_search integrada dispoñible automaticamente.

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

# Web search is automatically available!
# Shannon will use it when needed for current information

response = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[
        {"role": "user", "content": "What are the latest AI news today?"}
    ],
    # Optionally, explicitly define web_search tool
    tools=[{
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web for current information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"}
                },
                "required": ["query"]
            }
        }
    }]
)

print(response.choices[0].message.content)
# Response includes sources and citations

JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

// Web search is automatically available!
// Shannon will use it when needed for current information

const response = await client.chat.completions.create({
  model: 'shannon-1.6-lite',
  messages: [
    { role: 'user', content: 'What are the latest AI news today?' }
  ],
  // Optionally, explicitly define web_search tool
  tools: [{
    type: 'function',
    function: {
      name: 'web_search',
      description: 'Search the web for current information',
      parameters: {
        type: 'object',
        properties: {
          query: { type: 'string', description: 'Search query' }
        },
        required: ['query']
      }
    }
  }]
});

console.log(response.choices[0].message.content);
// Response includes sources and citations

Consello pro: Os resultados de busca web incluen citacions. Shannon citara as fontes automaticamente.

Anthropic

Shannon tamén admite o formato Messages API de Anthropic.

https://api.shannon-ai.com/v1/messages

Python

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/messages"
)

response = client.messages.create(
    model="shannon-1.6-lite",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Shannon!"}
    ],
    # Tool use (Anthropic format)
    tools=[{
        "name": "web_search",
        "description": "Search the web",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string"}
            },
            "required": ["query"]
        }
    }]
)

print(response.content[0].text)

JavaScript

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/messages'
});

const response = await client.messages.create({
  model: 'shannon-1.6-lite',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Hello, Shannon!' }
  ],
  // Tool use (Anthropic format)
  tools: [{
    name: 'web_search',
    description: 'Search the web',
    input_schema: {
      type: 'object',
      properties: {
        query: { type: 'string' }
      },
      required: ['query']
    }
  }]
});

console.log(response.content[0].text);

Cabeceira obrigatoria: O formato Anthropic require anthropic-version: 2023-06-01.

SDKs

Compatible

Usa calquera SDK de OpenAI ou Anthropic: só cambia a URL base.

OpenAI-Compatible SDKs

SDK Python

SDK oficial de OpenAI para Python - funciona con Shannon

pip install openai

Ver documentacion ->

SDK JavaScript / TypeScript

SDK oficial de OpenAI para Node.js - funciona con Shannon

npm install openai

Ver documentacion ->

SDK Go

Cliente Go da comunidade para APIs compatibles con OpenAI

go get github.com/sashabaranov/go-openai

Ver documentacion ->

SDK Ruby

Cliente Ruby da comunidade para APIs compatibles con OpenAI

gem install ruby-openai

Ver documentacion ->

SDK PHP

Cliente PHP da comunidade para APIs compatibles con OpenAI

composer require openai-php/client

Ver documentacion ->

SDK Rust

Cliente Rust asincrono para APIs compatibles con OpenAI

cargo add async-openai

Ver documentacion ->

Anthropic-Compatible SDKs

SDK Python (Anthropic)

SDK oficial de Anthropic para Python - funciona con Shannon

pip install anthropic

Ver documentacion ->

SDK TypeScript (Anthropic)

SDK oficial de Anthropic para TypeScript - funciona con Shannon

npm install @anthropic-ai/sdk

Ver documentacion ->

Xestión de erros

Shannon usa códigos de estado HTTP estándar e devolve mensaxes de erro detalladas.

400 Solicitude incorrecta Formato de solicitude ou parámetros non válidos

401 Non autorizado Clave API non válida ou ausente

402 Cota superada Cota de tokens ou busca superada

429 Límite de taxa Demasiadas solicitudes, reduce a velocidade

500 Erro do servidor Erro interno, tenta de novo máis tarde

Formato de resposta de erro

Resposta de erro

{
  "error": {
    "message": "Invalid API key provided",
    "type": "authentication_error",
    "code": "invalid_api_key"
  }
}

Rexistro de cambios

LOG

Actualizacións e melloras recentes da API de Shannon.

v2.1.0

2025-01-03

Novo Engadido o modelo shannon-coder-1 para integracion con Claude Code CLI
Novo Sistema de cota por chamadas para o modelo Coder
Mellorado Mellorada a fiabilidade da chamada de funcions

v2.0.0

2024-12-15

Novo Engadida compatibilidade coa API Messages de Anthropic
Novo Execucion de ferramentas en varios turnos (ata 10 iteracions)
Novo Soporte do formato de resposta JSON Schema
Mellorado Busca web mellorada con mellores citacions

v1.5.0

2024-11-20

Novo Engadido o modelo shannon-deep-dapo para razoamento complexo
Novo Funcion web_search integrada
Mellorado Reducida a latencia para respostas en streaming

v1.0.0

2024-10-01

Novo Lanzamento inicial da API
Novo Endpoint de chat completions compatible con OpenAI
Novo Soporte para chamada de funcions
Novo Streaming mediante Server-Sent Events

A túa clave API

Acceso

Usa tokens Bearer para chamadas OpenAI ou X-API-Key + anthropic-version.

YOUR_API_KEY

Obtén a túa clave API

Mantén a túa clave API en segredo. Rexenerar crea unha clave nova e invalida a vella.

O teu uso

Consulta o consumo de tokens e buscas nesta paxina cando inicias sesion na tua conta.

-- Chamadas de API

-- Tokens usados

Shannon API

Visión xeral

Capacidades

Substitución drop‑in

Chamada de funcións

Busca web integrada

Saídas estruturadas

Ferramentas multivolta

Streaming

Inicio rápido

Define o URL base

Engade a túa clave API

Envía a túa primeira mensaxe

Formato da resposta

Playground da API

Chat, Responses, Messages

Stream live output

Reuse your key

Autenticación

Formato OpenAI (Recomendado)

Anthropic

Modelos

Chamadas a funcións

Opcions de seleccion de ferramentas

Resposta de chamada de funcion

Saídas estruturadas

Opcions de formato de resposta

Streaming

Busca web

Anthropic

SDKs

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Xestión de erros

Formato de resposta de erro

Rexistro de cambios

A túa clave API

O teu uso

Shannon Coder (shannon-coder-1)

Listo para construír?

Shannon AI API Documentation

Visión xeral

Capacidades

Substitución drop‑in

Chamada de funcións

Busca web integrada

Saídas estruturadas

Ferramentas multivolta

Streaming

Inicio rápido

Define o URL base

Engade a túa clave API

Envía a túa primeira mensaxe

Formato da resposta

Playground da API

Chat, Responses, Messages

Stream live output

Reuse your key

Autenticación

Formato OpenAI (Recomendado)

Anthropic

Modelos

Chamadas a funcións

Opcions de seleccion de ferramentas

Resposta de chamada de funcion

Saídas estruturadas

Opcions de formato de resposta

Streaming

Busca web

Anthropic

SDKs

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Xestión de erros

Formato de resposta de erro

Rexistro de cambios

A túa clave API

O teu uso

Shannon Coder (shannon-coder-1)

Listo para construír?