Dokumentado de Shannon AI API

Superrigardo

Public docs

Ĉio, kion vi bezonas por liveri kun la OpenAI- kaj Anthropic-kongrua API de Shannon.

URL OpenAI-Compatible

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

Use the Chat Completions API with function calling and streaming.

URL Anthropic-Compatible

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

Claude Messages format with tools and anthropic-version header.

HTTP Aŭtentigo

Authorization: Bearer <api-key>

Or X-API-Key with anthropic-version for Claude-style calls.

Access Status

Public docs - Key required to call

Streaming, function calling, structured outputs, web search.

Launch checklist

+

Point your SDK at Shannon

Set baseURL to the OpenAI or Anthropic endpoints above.

Setup
+

Attach your API key

Use Bearer tokens for OpenAI calls or X-API-Key + anthropic-version.

Security
+

Enable tools & structured outputs

Supports OpenAI tools/functions, JSON schema, and built-in web_search.

Kapabloj
+

Track usage

View token and search consumption on this page when signed in to your account.

Analytics

Kapabloj

OpenAI + Anthropic

Enĵet-anstataŭigo por OpenAI kaj Anthropic API-oj kun denaska subteno por iloj, strukturitaj eligoj kaj enkonstruita retserĉo.

Drop‑in anstataŭigo

Kongrua

Funkcias kun la SDK‑oj de OpenAI kaj Anthropic. Nur ŝanĝu la bazan URL.

Funkciovoko

Iloj

Difinu ilojn, lasu Shannon voki ilin. Subtenas reĝimojn auto, forced kaj none.

Enkonstruita reta serĉo

Serĉo

Realtempa reta serĉo kun fontcitaĵoj. Aŭtomate disponebla.

Strukturitaj eligoj

JSON

JSON‑reĝimo kaj JSON‑skema devigo por fidinda datum‑eltiro.

Plurturnaj iloj

Agenta

Aŭtomataj funkcio‑ekzekutaj cikloj. Ĝis 10 iteracioj por peto.

Fluado

Rapida

Server‑sent events por realtempa token‑fluado.

Rapida komenco

5 minutoj

Komencu en tri paŝoj. Shannon spegulas OpenAI kaj Anthropic klientojn.

Agordu vian bazan URL

Uzu OpenAI‑kongruan endpointon.

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

Aldonu vian API‑ŝlosilon

Uzu Bearer‑aŭtentigon en la Authorization‑kaplinio.

Sendu vian unuan mesaĝon

Elektu lingvon kaj enmetu vian ŝlosilon.

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

Responda formato

Sukcesa respondo

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

API Ludejo

Nova

Testu la Shannon API rekte en via retumilo. Konstruu la peton, rulu ĝin kaj vidu la respondon realtempe.

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.

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

Provu la Playground V2 Akiru vian API-ŝlosilon

Aŭtentigo

Ĉiuj API-petoj postulas aŭtentigon per via Shannon API-ŝlosilo.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic

HTTP

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

Modeloj

Shannon ofertas plurajn modelojn optimumigitajn por malsamaj uzkazoj.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Kunteksto 128K

Konstruita por Sekurecaj Profesiuloj Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Kunteksto 128K

Konstruita por Sekurecaj Profesiuloj Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Kunteksto 128K

Konstruita por Sekurecaj Profesiuloj

shannon-2-pro Shannon 2 Pro

Kunteksto 128K

Konstruita por Sekurecaj Profesiuloj

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Kunteksto 128K

Konstruita por Sekurecaj Profesiuloj Code Generation, Tool Use, CLI Integration

Call-based quota

Funkci-alvokoj

Difinu ilojn, kiujn Shannon povas voki por fari agojn aŭ preni informojn.

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

Funkci-alvokoj

"auto" Model decides whether to call a function (default)

"none" Disable function calling for this request

{"type": "function", "function": {"name": "..."}} Force a specific function call

Responda formato

When model calls a function

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

Strukturitaj eligoj

Devigu Shannon respondi per valida JSON kiu kongruas kun via skemo.

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

Responda formato

{"type": "json_object"} Force valid JSON output (no specific schema)

{"type": "json_schema", "json_schema": {...}} Force output matching your exact schema

Fluigo

Ebligu realtempan token-fluigon per Server‑Sent Events por respondemaj UI-oj.

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

Tip: Streaming responses arrive as Server-Sent Events. Each chunk contains a delta with partial content.

Retserĉo

Shannon inkluzivas enkonstruitan web_search-funkcion kiu estas aŭtomate disponebla.

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

Konsilo: Web search results include citations. Shannon will automatically cite sources.

Anthropic

Shannon ankaŭ subtenas la Messages API-formaton 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);

Required: Anthropic format requires anthropic-version: 2023-06-01.

SDK-oj

Kongrua

Uzu ajnan OpenAI aŭ Anthropic SDK — simple ŝanĝu la bazan URL.

OpenAI-Compatible SDKs

SDK Python

Official OpenAI Python SDK - works with Shannon

pip install openai

View Docs ->

SDK JavaScript / TypeScript

Official OpenAI Node.js SDK - works with Shannon

npm install openai

View Docs ->

SDK Go

Community Go client for OpenAI-compatible APIs

go get github.com/sashabaranov/go-openai

View Docs ->

SDK Ruby

Community Ruby client for OpenAI-compatible APIs

gem install ruby-openai

View Docs ->

SDK PHP

Community PHP client for OpenAI-compatible APIs

composer require openai-php/client

View Docs ->

SDK Rust

Async Rust client for OpenAI-compatible APIs

cargo add async-openai

View Docs ->

Anthropic-Compatible SDKs

SDK Python (Anthropic)

Official Anthropic Python SDK - works with Shannon

pip install anthropic

View Docs ->

SDK TypeScript (Anthropic)

Official Anthropic TypeScript SDK - works with Shannon

npm install @anthropic-ai/sdk

View Docs ->

Erarotraktado

Shannon uzas normajn HTTP‑statokodojn kaj liveras detalajn erarmesaĝojn.

400 Malĝusta peto Nevalida peto‑formato aŭ parametroj

401 Neaŭtorizita Nevalida aŭ mankanta API‑ŝlosilo

402 Kvoto superita Tokena aŭ serĉa kvoto superita

429 Rapidlimigita Tro multaj petoj, malrapidigu

500 Servila eraro Interna eraro, reprovu poste

Erara respondo‑formato

Erara respondo

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

Ŝanĝprotokolo

LOG

Lastatempaj ĝisdatigoj kaj plibonigoj al la Shannon API.

v2.1.0

2025-01-03

Nova Added shannon-coder-1 model for Claude Code CLI integration
Nova Call-based quota system for Coder model
Improved Improved function calling reliability

v2.0.0

2024-12-15

Nova Added Anthropic Messages API compatibility
Nova Multi-turn tool execution (up to 10 iterations)
Nova JSON Schema response format support
Improved Enhanced web search with better citations

v1.5.0

2024-11-20

Nova Added shannon-deep-dapo model for complex reasoning
Nova Built-in web_search function
Improved Reduced latency for streaming responses

v1.0.0

2024-10-01

Nova Initial API release
Nova OpenAI-compatible chat completions endpoint
Nova Function calling support
Nova Streaming via Server-Sent Events

Via API‑ŝlosilo

Access

Use Bearer tokens for OpenAI calls or X-API-Key + anthropic-version.

YOUR_API_KEY

Akiru vian API-ŝlosilon

Tenu vian API‑ŝlosilon sekreta. Regenero kreas novan ŝlosilon kaj nuligas la malnovan.

Via uzado

View token and search consumption on this page when signed in to your account.

-- API‑vokoj

-- Uzitaj tokenoj

Shannon API

Superrigardo

Kapabloj

Drop‑in anstataŭigo

Funkciovoko

Enkonstruita reta serĉo

Strukturitaj eligoj

Plurturnaj iloj

Fluado

Rapida komenco

Agordu vian bazan URL

Aldonu vian API‑ŝlosilon

Sendu vian unuan mesaĝon

Responda formato

API Ludejo

Chat, Responses, Messages

Stream live output

Reuse your key

Aŭtentigo

OpenAI Format (Recommended)

Anthropic

Modeloj

Funkci-alvokoj

Funkci-alvokoj

Responda formato

Strukturitaj eligoj

Responda formato

Fluigo

Retserĉo

Anthropic

SDK-oj

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Erarotraktado

Erara respondo‑formato

Ŝanĝprotokolo

Via API‑ŝlosilo

Via uzado

Shannon Coder (shannon-coder-1)

Pretas konstrui?

Shannon AI API Documentation

Superrigardo

Kapabloj

Drop‑in anstataŭigo

Funkciovoko

Enkonstruita reta serĉo

Strukturitaj eligoj

Plurturnaj iloj

Fluado

Rapida komenco

Agordu vian bazan URL

Aldonu vian API‑ŝlosilon

Sendu vian unuan mesaĝon

Responda formato

API Ludejo

Chat, Responses, Messages

Stream live output

Reuse your key

Aŭtentigo

OpenAI Format (Recommended)

Anthropic

Modeloj

Funkci-alvokoj

Funkci-alvokoj

Responda formato

Strukturitaj eligoj

Responda formato

Fluigo

Retserĉo

Anthropic

SDK-oj

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Erarotraktado

Erara respondo‑formato

Ŝanĝprotokolo

Via API‑ŝlosilo

Via uzado

Shannon Coder (shannon-coder-1)

Pretas konstrui?