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.

CLI Coding Agents

NEW

Use Shannon as the AI backend for popular CLI coding agents. Read files, edit code, run tests — all powered by Shannon's API.

CLI Claude Code

Anthropic's official CLI coding agent. Point it at Shannon to use as your AI backend for reading, editing, and running code directly in your terminal.

ANTHROPIC_BASE_URL=https://api.shannon-ai.com ANTHROPIC_API_KEY=sk-YOUR_KEY claude --bare

Ver documentacion ->

CLI Codex CLI

OpenAI's open-source coding agent. Uses the Responses API for multi-turn tool use, file editing, and shell commands — all routed through Shannon.

OPENAI_BASE_URL=https://api.shannon-ai.com/v1 OPENAI_API_KEY=sk-YOUR_KEY codex

Ver documentacion ->

Claude Code

Anthropic's official CLI coding agent. Set two environment variables and launch with --bare to skip Anthropic account login.

Bash

# Install Claude Code (requires Node.js 18+)
npm install -g @anthropic-ai/claude-code

# Connect to Shannon AI as backend
export ANTHROPIC_BASE_URL=https://api.shannon-ai.com
export ANTHROPIC_API_KEY=sk-YOUR_API_KEY

# Launch Claude Code in bare mode (no Anthropic account needed)
claude --bare

# Or run a one-shot command
claude --bare -p "Explain this codebase"

# Claude Code will use Shannon's Anthropic-compatible API
# for all AI operations: reading files, editing code,
# running tests, and multi-turn tool use.

Shell Config

# Alternative: set env vars permanently in your shell profile
# ~/.bashrc or ~/.zshrc

export ANTHROPIC_BASE_URL=https://api.shannon-ai.com
export ANTHROPIC_API_KEY=sk-YOUR_API_KEY

# Then just run:
claude --bare

# Supported features through Shannon:
# - Multi-turn conversations with full context
# - File reading and editing (tool use)
# - Shell command execution
# - Streaming responses
# - All Claude Code slash commands (/compact, /clear, etc.)

Codex CLI

OpenAI's open-source coding agent. Uses the Responses API for multi-turn tool use, file editing, and shell commands.

Bash

# Install Codex CLI
npm install -g @openai/codex

# Connect to Shannon AI as backend
export OPENAI_BASE_URL=https://api.shannon-ai.com/v1
export OPENAI_API_KEY=sk-YOUR_API_KEY

# Launch Codex
codex

# Or run a one-shot command
codex "fix the bug in main.py"

# Codex uses the Responses API (POST /v1/responses)
# Shannon handles tool calls including:
# - Reading and writing files
# - Running shell commands
# - Multi-turn function calling

Shell Config

# Alternative: set env vars permanently
# ~/.bashrc or ~/.zshrc

export OPENAI_BASE_URL=https://api.shannon-ai.com/v1
export OPENAI_API_KEY=sk-YOUR_API_KEY

# Then just run:
codex

# Supported features through Shannon:
# - Responses API with full tool use
# - Function calling (file read/write, shell exec)
# - Streaming with real-time output
# - Multi-turn conversations
# - All Codex approval modes (suggest, auto-edit, full-auto)

How It Works: Both tools send standard API requests (Anthropic Messages or OpenAI Responses) to Shannon. Shannon routes them through Gemini with full tool-use support. No Anthropic or OpenAI account needed — just your Shannon API key.

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.2.0

2026-03-28

Novo Claude Code support — use Shannon as your Anthropic backend for the official CLI coding agent
Novo Codex CLI support — full Responses API with multi-turn tool use for OpenAI's coding agent
Mellorado Anthropic streaming format fixes — proper content_block lifecycle, tool_use deltas, toolu_ prefixes
Mellorado Schema sanitization for Gemini — strips $schema, additionalProperties, $ref and other unsupported fields from tool schemas

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

CLI Coding Agents

Claude Code

Codex CLI

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?