Documentação da API Shannon AI

Visão geral

Docs públicas

Tudo o que você precisa para lançar com a API compatível com OpenAI e Anthropic da Shannon.

URL base Compativel com OpenAI

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

Use a API Chat Completions com chamada de funcao e streaming.

URL base Compativel com Anthropic

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

Formato Claude Messages com ferramentas e cabecalho anthropic-version.

Cabecalhos Autenticacao

Authorization: Bearer <sua-chave>

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

Acesso Status

Documentacao publica - chave necessaria para chamar

Streaming, chamada de funcao, saidas estruturadas, pesquisa web.

Checklist de lancamento

+

Aponte seu SDK para a Shannon

Defina baseURL para os endpoints OpenAI ou Anthropic acima.

Configuracao
+

Anexe sua chave de API

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

Seguranca
+

Ative ferramentas e saidas estruturadas

Suporta OpenAI tools/functions, JSON schema e web_search integrado.

Capacidades
+

Acompanhe o uso

Veja o consumo de tokens e de pesquisa nesta pagina quando estiver conectado.

Analitica

Capacidades

OpenAI + Anthropic

Substituicao direta das APIs OpenAI e Anthropic com suporte nativo a ferramentas, saidas estruturadas e pesquisa web integrada.

Substituição direta

Compatível

Funciona com os SDKs da OpenAI e Anthropic. Basta mudar a URL base.

Chamada de funções

Ferramentas

Defina ferramentas e deixe a Shannon chamá‑las. Suporta modos auto, forçado e nenhum.

Busca web integrada

Busca

Busca na web em tempo real com citações de fontes. Disponível automaticamente.

Saídas estruturadas

JSON

Modo JSON e validação de JSON Schema para extração confiável de dados.

Ferramentas multi‑turno

Agêntico

Loops automáticos de execução de funções. Até 10 iterações por solicitação.

Streaming

Rápido

Eventos enviados pelo servidor para streaming de tokens em tempo real.

Início rápido

5 minutos

Comece em três passos. A Shannon espelha clientes OpenAI e Anthropic.

Defina sua URL base

Use o endpoint compatível com a OpenAI.

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

Adicione sua chave de API

Use autenticação Bearer no cabeçalho Authorization.

Envie sua primeira mensagem

Escolha um idioma e substitua pela sua chave.

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

Resposta de sucesso

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

Teste a API da Shannon diretamente no seu navegador. Monte sua requisição, execute e veja a resposta em 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.

/pt/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.

Testar Playground V2 Obter sua chave API

Autenticação

Todas as solicitacoes da API exigem autenticacao usando sua chave de API da Shannon.

Formato OpenAI (recomendado)

HTTP

Authorization: Bearer YOUR_API_KEY

Formato Anthropic

HTTP

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

Modelos

A Shannon oferece varios modelos otimizados para diferentes casos de uso.

shannon-1.6-lite Shannon 1.6 Lite

Respostas rapidas e eficientes para tarefas do dia a dia

Contexto 128K

Melhor para Chat, perguntas e respostas, geracao de conteudo

shannon-1.6-pro Shannon 1.6 Pro

Raciocinio avancado para problemas complexos

Contexto 128K

Melhor para Analise, pesquisa, tarefas complexas

shannon-2-lite Shannon 2 Lite

Contexto 128K

Melhor para

shannon-2-pro Shannon 2 Pro

Contexto 128K

Melhor para

shannon-coder-1 Shannon Coder

Otimizado para Claude Code CLI com cota por chamadas

Contexto 128K

Melhor para Geracao de codigo, uso de ferramentas, integracao com CLI

Cota por chamadas

Chamada de funções

Defina ferramentas que a Shannon pode chamar para executar acoes ou obter informacoes.

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

Opcoes de escolha de ferramenta

"auto" O modelo decide se deve chamar uma funcao (padrao)

"none" Desativar chamada de funcao para esta solicitacao

{"type": "function", "function": {"name": "..."}} Forcar a chamada de uma funcao especifica

Resposta da chamada de funcao

Quando o modelo chama uma funcao

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

Force a Shannon a responder com JSON valido que corresponda ao seu schema.

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

Opcoes de formato de resposta

{"type": "json_object"} Forcar saida JSON valida (sem schema especifico)

{"type": "json_schema", "json_schema": {...}} Forcar saida que corresponda exatamente ao seu schema

Streaming

Ative streaming de tokens em tempo real com Server-Sent Events para interfaces 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);
}

Dica: As respostas em streaming chegam como Server-Sent Events. Cada trecho contem um delta com conteudo parcial.

Busca web integrada

A Shannon inclui uma funcao web_search integrada que fica automaticamente disponivel.

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

Dica profissional: Resultados de pesquisa web incluem citacoes. A Shannon cita as fontes automaticamente.

Formato Anthropic

A Shannon tambem oferece suporte ao formato Messages da 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);

Cabecalho obrigatorio: O formato Anthropic exige 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 documentacao ->

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

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

Compativel

Use qualquer SDK OpenAI ou Anthropic - basta mudar a URL base.

SDKs compativeis com OpenAI

SDK Python

SDK Python oficial da OpenAI - funciona com Shannon

pip install openai

Ver documentacao ->

SDK JavaScript / TypeScript

SDK Node.js oficial da OpenAI - funciona com Shannon

npm install openai

Ver documentacao ->

SDK Go

Cliente Go da comunidade para APIs compativeis com OpenAI

go get github.com/sashabaranov/go-openai

Ver documentacao ->

SDK Ruby

Cliente Ruby da comunidade para APIs compativeis com OpenAI

gem install ruby-openai

Ver documentacao ->

SDK PHP

Cliente PHP da comunidade para APIs compativeis com OpenAI

composer require openai-php/client

Ver documentacao ->

SDK Rust

Cliente Rust assincrono para APIs compativeis com OpenAI

cargo add async-openai

Ver documentacao ->

SDKs compativeis com Anthropic

SDK Python (Anthropic)

SDK Python oficial da Anthropic - funciona com Shannon

pip install anthropic

Ver documentacao ->

SDK TypeScript (Anthropic)

SDK TypeScript oficial da Anthropic - funciona com Shannon

npm install @anthropic-ai/sdk

Ver documentacao ->

Tratamento de erros

A Shannon usa códigos HTTP padrão e retorna mensagens de erro detalhadas.

400 Requisição inválida Formato ou parâmetros de requisição inválidos

401 Não autorizado Chave API inválida ou ausente

402 Cota excedida Cota de tokens ou de busca excedida

429 Limite de taxa Muitas requisições, reduza a velocidade

500 Erro do servidor Erro interno, tente novamente mais tarde

Formato de resposta de erro

Resposta de erro

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

Registro de mudanças

LOG

Atualizacoes e melhorias recentes da API 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
Melhorado Anthropic streaming format fixes — proper content_block lifecycle, tool_use deltas, toolu_ prefixes
Melhorado Schema sanitization for Gemini — strips $schema, additionalProperties, $ref and other unsupported fields from tool schemas

v2.1.0

2025-01-03

Novo Adicionado o modelo shannon-coder-1 para integracao com Claude Code CLI
Novo Sistema de cota por chamadas para o modelo Coder
Melhorado Confiabilidade aprimorada de chamada de funcao

v2.0.0

2024-12-15

Novo Adicionada compatibilidade com Anthropic Messages API
Novo Execucao de ferramentas em multiplos turnos (ate 10 iteracoes)
Novo Suporte ao formato de resposta JSON Schema
Melhorado Pesquisa web aprimorada com melhores citacoes

v1.5.0

2024-11-20

Novo Adicionado o modelo shannon-deep-dapo para raciocinio complexo
Novo Funcao web_search integrada
Melhorado Latencia reduzida para respostas em streaming

v1.0.0

2024-10-01

Novo Lancamento inicial da API
Novo Endpoint de chat completions compativel com OpenAI
Novo Suporte a chamada de funcao
Novo Streaming via Server-Sent Events

Sua chave API

Acesso

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

YOUR_API_KEY

Obter sua chave API

Mantenha sua chave API em segredo. Regenerar cria uma nova chave e invalida a antiga.

Seu uso

Veja o consumo de tokens e de pesquisa nesta pagina quando estiver conectado.

-- Chamadas de API

-- Tokens usados

Shannon AI API Documentation

Visão geral

Capacidades

Substituição direta

Chamada de funções

Busca web integrada

Saídas estruturadas

Ferramentas multi‑turno

Streaming

Início rápido

Defina sua URL base

Adicione sua chave de API

Envie sua primeira mensagem

Formato de resposta

Playground da API

Chat, Responses, Messages

Stream live output

Reuse your key

Autenticação

Formato OpenAI (recomendado)

Formato Anthropic

Modelos

Chamada de funções

Opcoes de escolha de ferramenta

Resposta da chamada de funcao

Saídas estruturadas

Opcoes de formato de resposta

Streaming

Busca web integrada

Formato Anthropic

CLI Coding Agents

Claude Code

Codex CLI

SDKs

SDKs compativeis com OpenAI

SDKs compativeis com Anthropic

Tratamento de erros

Formato de resposta de erro

Registro de mudanças

Sua chave API

Seu uso

Shannon Coder (shannon-coder-1)

Pronto para construir?