Dokumentacja API Shannon AI

Przegląd

Publiczne dokumenty

Wszystko, czego potrzebujesz, aby wdrożyć z API Shannon zgodnym z OpenAI i Anthropic.

Bazowy URL Kompatybilne z OpenAI

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

Użyj Chat Completions API z function calling i streamingiem.

Bazowy URL Kompatybilne z Anthropic

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

Format Claude Messages z tools i nagłówkiem anthropic-version.

Nagłówki Uwierzytelnianie

Autoryzacja: Bearer <twoj-klucz>

Lub użyj X-API-Key z anthropic-version dla wywołań w stylu Claude.

Access Status

Public docs - Key required to call

Streaming, function calling, ustrukturyzowane odpowiedzi i wyszukiwanie w sieci.

Lista startowa

+

Skieruj swoje SDK do Shannon

Ustaw baseURL na endpoint OpenAI lub Anthropic powyżej.

Setup
+

Dodaj swój klucz API

Użyj Bearer dla OpenAI lub X-API-Key + anthropic-version.

Security
+

Włącz tools i ustrukturyzowane odpowiedzi

Obsługuje OpenAI tools/functions, JSON schema i wbudowane web_search.

Możliwości
+

Śledź użycie

Sprawdzaj zużycie tokenów i wyszukiwań na tej stronie po zalogowaniu.

Analytics

Możliwości

OpenAI + Anthropic

Bezpośredni zamiennik API OpenAI i Anthropic z natywną obsługą tools, ustrukturyzowanych odpowiedzi i wyszukiwania w sieci.

Zamiennik typu drop‑in

Zgodne

Działa z SDK OpenAI i Anthropic. Wystarczy zmienić bazowy URL.

Wywoływanie funkcji

Narzędzia

Zdefiniuj narzędzia, a Shannon je wywoła. Obsługuje tryby auto, wymuszony i brak.

Wbudowane wyszukiwanie w sieci

Szukaj

Wyszukiwanie w czasie rzeczywistym z cytowaniami źródeł. Dostępne automatycznie.

Ustrukturyzowane wyjścia

JSON

Tryb JSON i wymuszanie schematu JSON dla niezawodnego wydobycia danych.

Narzędzia wieloetapowe

Agentowe

Automatyczne pętle wywołań funkcji. Do 10 iteracji na żądanie.

Streaming

Szybkie

SSE do strumieniowania tokenów w czasie rzeczywistym.

Szybki start

5 minut

Zacznij w trzech krokach. Shannon naśladuje klientów OpenAI i Anthropic.

Ustaw bazowy URL

Użyj endpointu zgodnego z OpenAI.

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

Dodaj klucz API

Użyj Bearer auth w nagłówku Authorization.

Wyślij pierwszą wiadomość

Wybierz język i wstaw swój klucz.

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

Format odpowiedzi

Odpowiedź sukcesu

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

Plac zabaw API

Nowe

Testuj API Shannon bezpośrednio w przeglądarce. Zbuduj żądanie, uruchom i zobacz odpowiedź w czasie rzeczywistym.

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.

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

Wypróbuj Playground V2 Uzyskaj klucz API

Uwierzytelnianie

Wszystkie żądania API wymagają uwierzytelnienia Twoim kluczem API Shannon.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Format Anthropic

HTTP

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

Modele

Shannon oferuje wiele modeli zoptymalizowanych pod różne przypadki użycia.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Kontekst 128K

Najlepsze do Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Kontekst 128K

Najlepsze do Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Kontekst 128K

Najlepsze do

shannon-2-pro Shannon 2 Pro

Kontekst 128K

Najlepsze do

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Kontekst 128K

Najlepsze do Code Generation, Tool Use, CLI Integration

Call-based quota

Wywołanie funkcji

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

Opcje wyboru narzędzia

"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

Odpowiedź wywołania funkcji

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

Ustrukturyzowane odpowiedzi

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

Opcje formatu odpowiedzi

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

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

Wbudowane wyszukiwanie w sieci

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

Wskazówka pro: Wyniki wyszukiwania zawierają cytowania. Shannon automatycznie cytuje źródła.

Format Anthropic

Shannon obsługuje również format 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);

Wymagany nagłówek: Anthropic format requires anthropic-version: 2023-06-01.

SDK

Zgodne

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

Obsługa błędów

Shannon używa standardowych kodów HTTP i zwraca szczegółowe komunikaty błędów.

400 Błędne żądanie Nieprawidłowy format żądania lub parametry

401 Brak autoryzacji Nieprawidłowy lub brakujący klucz API

402 Przekroczony limit Przekroczono limit tokenów lub wyszukiwań

429 Ograniczenie szybkości Zbyt wiele żądań, zwolnij

500 Błąd serwera Błąd wewnętrzny, spróbuj ponownie później

Format odpowiedzi błędu

Odpowiedź błędu

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

Dziennik zmian

LOG

Recent updates and improvements to the Shannon API.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

Twój klucz API

Access

Użyj Bearer dla OpenAI lub X-API-Key + anthropic-version.

YOUR_API_KEY

Uzyskaj klucz API

Trzymaj klucz API w tajemnicy. Regeneracja tworzy nowy klucz i unieważnia stary.

Twoje użycie

Sprawdzaj zużycie tokenów i wyszukiwań na tej stronie po zalogowaniu.

-- Wywołania API

-- Użyte tokeny

API Shannon

Przegląd

Możliwości

Zamiennik typu drop‑in

Wywoływanie funkcji

Wbudowane wyszukiwanie w sieci

Ustrukturyzowane wyjścia

Narzędzia wieloetapowe

Streaming

Szybki start

Ustaw bazowy URL

Dodaj klucz API

Wyślij pierwszą wiadomość

Format odpowiedzi

Plac zabaw API

Chat, Responses, Messages

Stream live output

Reuse your key

Uwierzytelnianie

OpenAI Format (Recommended)

Format Anthropic

Modele

Wywołanie funkcji

Opcje wyboru narzędzia

Odpowiedź wywołania funkcji

Ustrukturyzowane odpowiedzi

Opcje formatu odpowiedzi

Streaming

Wbudowane wyszukiwanie w sieci

Format Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Obsługa błędów

Format odpowiedzi błędu

Dziennik zmian

Twój klucz API

Twoje użycie

Shannon Coder (shannon-coder-1)

Gotowy do budowy?

Shannon AI API Documentation

Przegląd

Możliwości

Zamiennik typu drop‑in

Wywoływanie funkcji

Wbudowane wyszukiwanie w sieci

Ustrukturyzowane wyjścia

Narzędzia wieloetapowe

Streaming

Szybki start

Ustaw bazowy URL

Dodaj klucz API

Wyślij pierwszą wiadomość

Format odpowiedzi

Plac zabaw API

Chat, Responses, Messages

Stream live output

Reuse your key

Uwierzytelnianie

OpenAI Format (Recommended)

Format Anthropic

Modele

Wywołanie funkcji

Opcje wyboru narzędzia

Odpowiedź wywołania funkcji

Ustrukturyzowane odpowiedzi

Opcje formatu odpowiedzi

Streaming

Wbudowane wyszukiwanie w sieci

Format Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Obsługa błędów

Format odpowiedzi błędu

Dziennik zmian

Twój klucz API

Twoje użycie

Shannon Coder (shannon-coder-1)

Gotowy do budowy?