Dokumentace Shannon AI API

Přehled

Veřejné dokumenty

Vše, co potřebujete pro spuštění s OpenAI/Anthropic kompatibilním API Shannon.

Základní URL Kompatibilní s OpenAI

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

Použijte Chat Completions API s function calling a streamingem.

Základní URL Kompatibilní s Anthropic

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

Formát Claude Messages s tools a hlavičkou anthropic-version.

Hlavičky Ověření

Autorizace: Bearer <vas-klic>

Nebo použijte X-API-Key s anthropic-version pro volání ve stylu Claude.

Access Status

Public docs - Key required to call

Streaming, function calling, strukturované výstupy a webové vyhledávání.

Spouštěcí checklist

+

Nasměrujte svůj SDK na Shannon

Nastavte baseURL na endpoint OpenAI nebo Anthropic výše.

Setup
+

Přidejte svůj API klíč

Použijte Bearer pro OpenAI nebo X-API-Key + anthropic-version.

Security
+

Zapněte tools a strukturované výstupy

Podporuje OpenAI tools/functions, JSON schema a vestavěné web_search.

Možnosti
+

Sledujte využití

Na této stránce po přihlášení sledujte spotřebu tokenů a vyhledávání.

Analytics

Možnosti

OpenAI + Anthropic

Přímá náhrada API OpenAI a Anthropic s nativní podporou tools, strukturovaných výstupů a webového vyhledávání.

Drop‑in náhrada

Kompatibilní

Funguje se SDK OpenAI a Anthropic. Stačí změnit základní URL.

Volání funkcí

Nástroje

Definujte nástroje, nechte Shannon je volat. Podporuje režimy auto, vynucený a žádný.

Vestavěné webové vyhledávání

Hledat

Vyhledávání v reálném čase s citacemi zdrojů. Automaticky dostupné.

Strukturované výstupy

JSON

Režim JSON a vynucení schématu JSON pro spolehlivou extrakci dat.

Vícekolové nástroje

Agentní

Automatické smyčky volání funkcí. Až 10 iterací na požadavek.

Streaming

Rychlé

Server‑sent events pro streamování tokenů v reálném čase.

Rychlý start

5 minut

Začněte ve třech krocích. Shannon zrcadlí klienty OpenAI a Anthropic.

Nastavte základní URL

Použijte endpoint kompatibilní s OpenAI.

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

Přidejte API klíč

Použijte Bearer auth v hlavičce Authorization.

Odešlete první zprávu

Vyberte jazyk a vložte svůj klíč.

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

Formát odpovědi

Úspěšná odpověď

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

Nové

Testujte Shannon API přímo v prohlížeči. Sestavte požadavek, spusťte ho a sledujte odpověď v reálném čase.

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.

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

Vyzkoušet Playground V2 Získat API klíč

Ověření

Všechny API požadavky vyžadují autentizaci pomocí vašeho API klíče Shannon.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Formát Anthropic

HTTP

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

Modely

Shannon nabízí více modelů optimalizovaných pro různé případy použití.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Kontext 128K

Nejlepší pro Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Kontext 128K

Nejlepší pro Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Kontext 128K

Nejlepší pro

shannon-2-pro Shannon 2 Pro

Kontext 128K

Nejlepší pro

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Kontext 128K

Nejlepší pro Code Generation, Tool Use, CLI Integration

Call-based quota

Volání funkcí

Define tools that Shannon can call to perform actions or retrieve information.

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

Možnosti volby nástroje

"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

Odpověď volání funkce

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

Strukturované výstupy

Force Shannon to respond with valid JSON that matches your 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" }

Možnosti formátu odpovědi

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

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

Streaming

Enable real-time token streaming with Server-Sent Events for responsive UIs.

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.

Vestavěné webové vyhledávání

Shannon includes a built-in web_search function that's automatically available.

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

Pro tip: Výsledky webového vyhledávání obsahují citace. Shannon bude zdroje citovat automaticky.

Formát Anthropic

Shannon také podporuje formát Anthropic Messages API.

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

Povinná hlavička: Anthropic format requires anthropic-version: 2023-06-01.

SDK

Kompatibilní

Use any OpenAI or Anthropic SDK - just change the base 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 ->

Zpracování chyb

Shannon používá standardní HTTP kódy a vrací podrobné chybové zprávy.

400 Špatný požadavek Neplatný formát požadavku nebo parametry

401 Neautorizováno Neplatný nebo chybějící API klíč

402 Překročený limit Překročen limit tokenů nebo vyhledávání

429 Omezeno rychlostí Příliš mnoho požadavků, zpomalte

500 Chyba serveru Interní chyba, zkuste později

Formát chybové odpovědi

Chybová odpověď

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

Přehled změn

LOG

Recent updates and improvements to the Shannon API.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

Váš API klíč

Access

Použijte Bearer pro OpenAI nebo X-API-Key + anthropic-version.

YOUR_API_KEY

Získat API klíč

Uchovávejte API klíč v tajnosti. Regenerace vytvoří nový klíč a zneplatní starý.

Vaše využití

Na této stránce po přihlášení sledujte spotřebu tokenů a vyhledávání.

-- API volání

-- Použité tokeny

Shannon API

Přehled

Možnosti

Drop‑in náhrada

Volání funkcí

Vestavěné webové vyhledávání

Strukturované výstupy

Vícekolové nástroje

Streaming

Rychlý start

Nastavte základní URL

Přidejte API klíč

Odešlete první zprávu

Formát odpovědi

Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Ověření

OpenAI Format (Recommended)

Formát Anthropic

Modely

Volání funkcí

Možnosti volby nástroje

Odpověď volání funkce

Strukturované výstupy

Možnosti formátu odpovědi

Streaming

Vestavěné webové vyhledávání

Formát Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Zpracování chyb

Formát chybové odpovědi

Přehled změn

Váš API klíč

Vaše využití

Shannon Coder (shannon-coder-1)

Připraveni stavět?

Shannon AI API Documentation

Přehled

Možnosti

Drop‑in náhrada

Volání funkcí

Vestavěné webové vyhledávání

Strukturované výstupy

Vícekolové nástroje

Streaming

Rychlý start

Nastavte základní URL

Přidejte API klíč

Odešlete první zprávu

Formát odpovědi

Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Ověření

OpenAI Format (Recommended)

Formát Anthropic

Modely

Volání funkcí

Možnosti volby nástroje

Odpověď volání funkce

Strukturované výstupy

Možnosti formátu odpovědi

Streaming

Vestavěné webové vyhledávání

Formát Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Zpracování chyb

Formát chybové odpovědi

Přehled změn

Váš API klíč

Vaše využití

Shannon Coder (shannon-coder-1)

Připraveni stavět?