Shannon AI API‑dokumentation

Översikt

Publika docs

Allt du behöver för att lansera med Shannons OpenAI‑ och Anthropic‑kompatibla API.

Bas-URL OpenAI-kompatibel

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

Använd Chat Completions API med function calling och streaming.

Bas-URL Anthropic-kompatibel

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

Claude Messages-format med tools och anthropic-version-header.

Rubriker Autentisering

Auktorisering: Bearer <din-nyckel>

Eller använd X-API-Key med anthropic-version för anrop i Claude-stil.

Access Status

Public docs - Key required to call

Streaming, function calling, strukturerade svar och webbsökning.

Lanseringschecklista

+

Peka ditt SDK till Shannon

Sätt baseURL till OpenAI- eller Anthropic-endpointen ovan.

Setup
+

Lägg till din API-nyckel

Använd Bearer för OpenAI eller X-API-Key + anthropic-version.

Security
+

Aktivera tools och strukturerade svar

Stöder OpenAI tools/functions, JSON schema och inbyggd web_search.

Funktioner
+

Följ användning

Se token- och sökförbrukning på den här sidan när du är inloggad.

Analytics

Funktioner

OpenAI + Anthropic

Direkt ersättning för OpenAI- och Anthropic-API:er med inbyggt stöd för tools, strukturerade svar och webbsökning.

Direkt ersättning

Kompatibel

Fungerar med OpenAI‑ och Anthropic‑SDK:er. Byt bara base‑URL.

Funktionsanrop

Verktyg

Definiera verktyg och låt Shannon anropa dem. Stöd för auto, forced och none‑läge.

Inbyggd webbsök

Sök

Webbsök i realtid med källhänvisningar. Tillgänglig automatiskt.

Strukturerade utdata

JSON

JSON‑läge och JSON Schema‑tvingning för pålitlig dataextraktion.

Multi‑turn‑verktyg

Agentisk

Automatiska funktionsloopar. Upp till 10 iterationer per begäran.

Streaming

Snabb

Server‑Sent Events för realtids‑tokenstreaming.

Snabbstart

5 minuter

Kom igång i tre steg. Shannon speglar OpenAI‑ och Anthropic‑klienter.

Ställ in din base‑URL

Använd den OpenAI‑kompatibla endpointen.

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

Lägg till din API‑nyckel

Använd Bearer‑auth i Authorization‑headern.

Skicka ditt första meddelande

Välj språk och ersätt med din nyckel.

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

Svarformat

Lyckat svar

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

Testa Shannon‑API direkt i webbläsaren. Bygg din begäran, kör den och se svaret i realtid.

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.

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

Testa Playground V2 Hämta din API‑nyckel

Autentisering

Alla API-anrop kräver autentisering med din Shannon API-nyckel.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic‑format

HTTP

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

Modeller

Shannon erbjuder flera modeller optimerade för olika användningsfall.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Kontext 128K

Bäst för Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Kontext 128K

Bäst för Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Kontext 128K

Bäst för

shannon-2-pro Shannon 2 Pro

Kontext 128K

Bäst för

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Kontext 128K

Bäst för Code Generation, Tool Use, CLI Integration

Call-based quota

Funktionsanrop

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

Alternativ för verktygsval

"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

Svar på funktionsanrop

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

Strukturerade utdata

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

Alternativ för svarsformat

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

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

Inbyggd webbsökning

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

Proffstips: Webbsökresultat innehåller källhänvisningar. Shannon citerar källor automatiskt.

Anthropic‑format

Shannon stöder även Anthropic Messages API-formatet.

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

Obligatorisk header: Anthropic format requires anthropic-version: 2023-06-01.

SDK:er

Kompatibel

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

Felhantering

Shannon använder standardiserade HTTP‑statuskoder och returnerar detaljerade felmeddelanden.

400 Ogiltig begäran Ogiltigt format eller parametrar

401 Obehörig Ogiltig eller saknad API‑nyckel

402 Kvot överskriden Token- eller sökkvot överskriden

429 Hastighetsbegränsad För många förfrågningar, sakta ner

500 Serverfel Internt fel, försök igen senare

Felsvarsformat

Felsvar

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

Ändringslogg

LOG

Recent updates and improvements to the Shannon API.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

Din API‑nyckel

Access

Använd Bearer för OpenAI eller X-API-Key + anthropic-version.

YOUR_API_KEY

Hämta din API‑nyckel

Håll din API‑nyckel hemlig. Att skapa en ny nyckel gör den gamla ogiltig.

Din användning

Se token- och sökförbrukning på den här sidan när du är inloggad.

-- API‑anrop

-- Använda tokens

Shannon API

Översikt

Funktioner

Direkt ersättning

Funktionsanrop

Inbyggd webbsök

Strukturerade utdata

Multi‑turn‑verktyg

Streaming

Snabbstart

Ställ in din base‑URL

Lägg till din API‑nyckel

Skicka ditt första meddelande

Svarformat

API‑Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Autentisering

OpenAI Format (Recommended)

Anthropic‑format

Modeller

Funktionsanrop

Alternativ för verktygsval

Svar på funktionsanrop

Strukturerade utdata

Alternativ för svarsformat

Streaming

Inbyggd webbsökning

Anthropic‑format

SDK:er

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Felhantering

Felsvarsformat

Ändringslogg

Din API‑nyckel

Din användning

Shannon Coder (shannon-coder-1)

Redo att bygga?

Shannon AI API Documentation

Översikt

Funktioner

Direkt ersättning

Funktionsanrop

Inbyggd webbsök

Strukturerade utdata

Multi‑turn‑verktyg

Streaming

Snabbstart

Ställ in din base‑URL

Lägg till din API‑nyckel

Skicka ditt första meddelande

Svarformat

API‑Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Autentisering

OpenAI Format (Recommended)

Anthropic‑format

Modeller

Funktionsanrop

Alternativ för verktygsval

Svar på funktionsanrop

Strukturerade utdata

Alternativ för svarsformat

Streaming

Inbyggd webbsökning

Anthropic‑format

SDK:er

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Felhantering

Fel­svarsformat

Ändringslogg

Din API‑nyckel

Din användning

Shannon Coder (shannon-coder-1)

Redo att bygga?

Felsvarsformat