Shannon AI API Dokumentācija

Pārskats

Public docs

Viss, kas nepieciešams, lai palaistu ar Shannon OpenAI un Anthropic saderīgu API.

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 Autentifikācija

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.

Iespējas
+

Track usage

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

Analytics

Iespējas

OpenAI + Anthropic

Drop‑in aizstājējs OpenAI un Anthropic API ar iebūvētu atbalstu rīkiem, strukturētiem izvadiem un tīmekļa meklēšanai.

Drop‑in aizvietotājs

Saderīgs

Darbojas ar OpenAI un Anthropic SDK. Vienkārši nomainiet bāzes URL.

Funkciju izsaukšana

Rīki

Definējiet rīkus, ļaujiet Shannon tos izsaukt. Atbalsta auto, forced un none režīmus.

Iebūvēta tīmekļa meklēšana

Meklēt

Reāllaika tīmekļa meklēšana ar avotu citātiem. Pieejama automātiski.

Strukturēti izvadi

JSON

JSON režīms un JSON Schema piespiedu piemērošana uzticamai datu ieguvei.

Daudzposmu rīki

Aģentiskais

Automātiskas funkciju izpildes cilpas. Līdz 10 iterācijām uz pieprasījumu.

Straumēšana

Ātrs

Server‑sent events reāllaika tokenu straumēšanai.

Ātrais sākums

5 minūtes

Sāciet trīs soļos. Shannon atspoguļo OpenAI un Anthropic klientus.

Iestatiet bāzes URL

Izmantojiet ar OpenAI saderīgu endpoint.

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

Pievienojiet API atslēgu

Authorization galvenē izmantojiet Bearer auth.

Nosūtiet pirmo ziņojumu

Izvēlieties valodu un ievadiet savu atslēgu.

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

Atbildes formāts

Veiksmīga atbilde

{
  "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 spēļlaukums

Jauns

Testējiet Shannon API tieši pārlūkā. Izveidojiet pieprasījumu, palaidiet un skatiet atbildi reāllaikā.

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.

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

Izmēģiniet Playground V2 Saņemiet savu API atslēgu

Autentifikācija

Visiem API pieprasījumiem nepieciešama autentifikācija ar jūsu Shannon API atslēgu.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic

HTTP

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

Modeļi

Shannon piedāvā vairākus modeļus, kas optimizēti dažādiem lietošanas gadījumiem.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Konteksts 128K

Būvēts Drošības Profesionāļiem Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Konteksts 128K

Būvēts Drošības Profesionāļiem Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Konteksts 128K

Būvēts Drošības Profesionāļiem

shannon-2-pro Shannon 2 Pro

Konteksts 128K

Būvēts Drošības Profesionāļiem

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Konteksts 128K

Būvēts Drošības Profesionāļiem Code Generation, Tool Use, CLI Integration

Call-based quota

Funkciju izsaukšana

Definējiet rīkus, ko Shannon var izsaukt, lai veiktu darbības vai iegūtu informāciju.

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

Funkciju izsaukšana

"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

Atbildes formāts

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

Strukturēti izvadi

Piespiediet Shannon atbildēt ar derīgu JSON, kas atbilst jūsu shēmai.

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

Atbildes formāts

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

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

Straumēšana

Ieslēdziet reāllaika tokenu straumēšanu ar Server‑Sent Events, lai UI būtu atsaucīgs.

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.

Tīmekļa meklēšana

Shannon ietver iebūvētu web_search funkciju, kas ir automātiski pieejama.

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

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

Anthropic

Shannon arī atbalsta Anthropic Messages API formātu.

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

Saderīgs

Izmantojiet jebkuru OpenAI vai Anthropic SDK — vienkārši nomainiet bāzes 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 ->

Kļūdu apstrāde

Shannon izmanto standarta HTTP statusa kodus un atgriež detalizētus kļūdu ziņojumus.

400 Nederīgs pieprasījums Nederīgs pieprasījuma formāts vai parametri

401 Neautorizēts Nederīga vai trūkstoša API atslēga

402 Kvota pārsniegta Tokenu vai meklēšanas kvota pārsniegta

429 Ātruma ierobežojums Pārāk daudz pieprasījumu, palēniniet

500 Servera kļūda Iekšēja kļūda, mēģiniet vēlāk

Kļūdas atbildes formāts

Kļūdas atbilde

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

Izmaiņu žurnāls

LOG

Jaunākie Shannon API atjauninājumi un uzlabojumi.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

Jūsu API atslēga

Access

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

YOUR_API_KEY

Saņemiet savu API atslēgu

Glabājiet API atslēgu slepeni. Atjaunošana izveido jaunu atslēgu un anulē veco.

Jūsu lietojums

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

-- API izsaukumi

-- Izmantotie tokeni

Shannon API

Pārskats

Iespējas

Drop‑in aizvietotājs

Funkciju izsaukšana

Iebūvēta tīmekļa meklēšana

Strukturēti izvadi

Daudzposmu rīki

Straumēšana

Ātrais sākums

Iestatiet bāzes URL

Pievienojiet API atslēgu

Nosūtiet pirmo ziņojumu

Atbildes formāts

API spēļlaukums

Chat, Responses, Messages

Stream live output

Reuse your key

Autentifikācija

OpenAI Format (Recommended)

Anthropic

Modeļi

Funkciju izsaukšana

Funkciju izsaukšana

Atbildes formāts

Strukturēti izvadi

Atbildes formāts

Straumēšana

Tīmekļa meklēšana

Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Kļūdu apstrāde

Kļūdas atbildes formāts

Izmaiņu žurnāls

Jūsu API atslēga

Jūsu lietojums

Shannon Coder (shannon-coder-1)

Gatavs veidot?

Shannon AI API Documentation

Pārskats

Iespējas

Drop‑in aizvietotājs

Funkciju izsaukšana

Iebūvēta tīmekļa meklēšana

Strukturēti izvadi

Daudzposmu rīki

Straumēšana

Ātrais sākums

Iestatiet bāzes URL

Pievienojiet API atslēgu

Nosūtiet pirmo ziņojumu

Atbildes formāts

API spēļlaukums

Chat, Responses, Messages

Stream live output

Reuse your key

Autentifikācija

OpenAI Format (Recommended)

Anthropic

Modeļi

Funkciju izsaukšana

Funkciju izsaukšana

Atbildes formāts

Strukturēti izvadi

Atbildes formāts

Straumēšana

Tīmekļa meklēšana

Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Kļūdu apstrāde

Kļūdas atbildes formāts

Izmaiņu žurnāls

Jūsu API atslēga

Jūsu lietojums

Shannon Coder (shannon-coder-1)

Gatavs veidot?