Shannon AI API Dokumentacija

Apžvalga

Public docs

Viskas, ko reikia paleisti su Shannon OpenAI ir Anthropic suderinamu 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 Autentifikavimas

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.

Galimybės
+

Track usage

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

Analytics

Galimybės

OpenAI + Anthropic

Drop‑in pakaitalas OpenAI ir Anthropic API su natūralia įrankių, struktūruotų išėjimų ir integruotos žiniatinklio paieškos parama.

Drop‑in pakeitimas

Suderinama

Veikia su OpenAI ir Anthropic SDK. Tiesiog pakeiskite bazinį URL.

Funkcijų iškvietimas

Įrankiai

Apibrėžkite įrankius, leiskite Shannon juos kviesti. Palaiko auto, forced ir none režimus.

Integruota žiniatinklio paieška

Paieška

Realaus laiko paieška su šaltinių citatomis. Pasiekiama automatiškai.

Struktūruotos išvestys

JSON

JSON režimas ir JSON Schema taikymas patikimam duomenų išgavimui.

Daugiapakopiai įrankiai

Agentinis

Automatiniai funkcijų vykdymo ciklai. Iki 10 iteracijų per užklausą.

Srautinimas

Greita

Server‑sent events realaus laiko žetonų srautui.

Greita pradžia

5 minutės

Pradėkite per tris žingsnius. Shannon atspindi OpenAI ir Anthropic klientus.

Nustatykite bazinį URL

Naudokite su OpenAI suderinamą endpoint.

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

Pridėkite API raktą

Naudokite Bearer auth Authorization antraštėje.

Išsiųskite pirmą žinutę

Pasirinkite kalbą ir įrašykite savo raktą.

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

Atsakymo formatas

Sėkmingas atsakymas

{
  "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 žaidimų aikštelė

Nauja

Išbandykite Shannon API tiesiai naršyklėje. Sukurkite užklausą, paleiskite ir matykite atsaką realiu laiku.

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.

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

Išbandykite Playground V2 Gaukite savo API raktą

Autentifikavimas

Visoms API užklausoms reikalingas autentifikavimas naudojant jūsų Shannon API raktą.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic

HTTP

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

Modeliai

Shannon siūlo kelis modelius, optimizuotus skirtingiems naudojimo atvejams.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Kontekstas 128K

Sukurta Saugumo Profesionalams Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Kontekstas 128K

Sukurta Saugumo Profesionalams Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Kontekstas 128K

Sukurta Saugumo Profesionalams

shannon-2-pro Shannon 2 Pro

Kontekstas 128K

Sukurta Saugumo Profesionalams

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Kontekstas 128K

Sukurta Saugumo Profesionalams Code Generation, Tool Use, CLI Integration

Call-based quota

Funkcijų kvietimas

Apibrėžkite įrankius, kuriuos Shannon gali kviesti veiksmams atlikti ar informacijai gauti.

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

Funkcijų kvietimas

"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

Atsakymo formatas

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

Struktūruoti išėjimai

Priverskite Shannon atsakyti galiojančiu JSON, atitinkančiu jūsų schemą.

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

Atsakymo formatas

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

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

Srautinė transliacija

Įjunkite realaus laiko žetonų srautą su Server‑Sent Events, kad UI būtų greitai reaguojantis.

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.

Žiniatinklio paieška

Shannon turi integruotą web_search funkciją, kuri yra automatiškai prieinama.

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

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

Anthropic

Shannon taip pat palaiko Anthropic Messages API formatą.

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.

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

View Docs ->

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

View Docs ->

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.

SDK

Suderinama

Naudokite bet kurį OpenAI ar Anthropic SDK — tiesiog pakeiskite bazinį 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 ->

Klaidų tvarkymas

Shannon naudoja standartinius HTTP būsenos kodus ir grąžina detalias klaidas.

400 Netinkama užklausa Netinkamas užklausos formatas arba parametrai

401 Neautorizuota Neteisingas arba trūkstamas API raktas

402 Viršyta kvota Viršyta žetonų arba paieškos kvota

429 Apribotas greitis Per daug užklausų, sulėtinkite

500 Serverio klaida Vidinė klaida, bandykite vėliau

Klaidos atsakymo formatas

Klaidos atsakymas

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

Pakeitimų žurnalas

LOG

Naujausi Shannon API atnaujinimai ir patobulinimai.

v2.2.0

2026-03-28

Nauja Claude Code support — use Shannon as your Anthropic backend for the official CLI coding agent
Nauja Codex CLI support — full Responses API with multi-turn tool use for OpenAI's coding agent
Improved Anthropic streaming format fixes — proper content_block lifecycle, tool_use deltas, toolu_ prefixes
Improved Schema sanitization for Gemini — strips $schema, additionalProperties, $ref and other unsupported fields from tool schemas

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

Jūsų API raktas

Access

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

YOUR_API_KEY

Gaukite savo API raktą

Saugokite API raktą. Atnaujinimas sukuria naują raktą ir panaikina seną.

Jūsų naudojimas

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

-- API iškvietimai

-- Naudoti žetonai

Shannon AI API Documentation

Apžvalga

Galimybės

Drop‑in pakeitimas

Funkcijų iškvietimas

Integruota žiniatinklio paieška

Struktūruotos išvestys

Daugiapakopiai įrankiai

Srautinimas

Greita pradžia

Nustatykite bazinį URL

Pridėkite API raktą

Išsiųskite pirmą žinutę

Atsakymo formatas

API žaidimų aikštelė

Chat, Responses, Messages

Stream live output

Reuse your key

Autentifikavimas

OpenAI Format (Recommended)

Anthropic

Modeliai

Funkcijų kvietimas

Funkcijų kvietimas

Atsakymo formatas

Struktūruoti išėjimai

Atsakymo formatas

Srautinė transliacija

Žiniatinklio paieška

Anthropic

CLI Coding Agents

Claude Code

Codex CLI

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Klaidų tvarkymas

Klaidos atsakymo formatas

Pakeitimų žurnalas

Jūsų API raktas

Jūsų naudojimas

Shannon Coder (shannon-coder-1)

Pasiruošę kurti?