Shannon AI API‑Dokumentation

Überblick

Öffentliche Docs

Alles, was du brauchst, um mit Shannons OpenAI‑ und Anthropic‑kompatibler API zu shippen.

Basis-URL OpenAI-kompatibel

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

Nutze die Chat-Completions-API mit Function Calling und Streaming.

Basis-URL Anthropic-kompatibel

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

Claude-Messages-Format mit Tools und anthropic-version-Header.

Header Authentifizierung

Autorisierung: Bearer <dein-schluessel>

Oder nutze X-API-Key mit anthropic-version für Claude-ähnliche Aufrufe.

Access Status

Public docs - Key required to call

Streaming, Function Calling, strukturierte Ausgaben und Websuche.

Launch-Checkliste

+

Richte dein SDK auf Shannon aus

Setze baseURL auf den OpenAI- oder Anthropic-Endpunkt oben.

Setup
+

Füge deinen API-Schlüssel hinzu

Nutze Bearer für OpenAI oder X-API-Key + anthropic-version.

Security
+

Aktiviere Tools und strukturierte Ausgaben

Unterstützt OpenAI tools/functions, JSON schema und integrierte web_search.

Funktionen
+

Nutzung verfolgen

Sieh Token- und Suchverbrauch auf dieser Seite nach dem Login.

Analytics

Funktionen

OpenAI + Anthropic

Direkter Ersatz für OpenAI- und Anthropic-APIs mit nativer Unterstützung für Tools, strukturierte Ausgaben und Websuche.

Direkter Ersatz

Kompatibel

Funktioniert mit OpenAI‑ und Anthropic‑SDKs. Einfach die Basis‑URL ändern.

Funktionsaufrufe

Tools

Definieren Sie Tools und lassen Sie Shannon sie aufrufen. Unterstützt die Modi auto, erzwungen und keiner.

Integrierte Websuche

Suche

Echtzeit‑Websuche mit Quellenangaben. Automatisch verfügbar.

Strukturierte Ausgaben

JSON

JSON‑Modus und JSON‑Schema‑Erzwingung für zuverlässige Datenextraktion.

Multi‑Turn‑Tools

Agentisch

Automatische Funktionsausführungsschleifen. Bis zu 10 Iterationen pro Anfrage.

Streaming

Schnell

Server‑Sent Events für Echtzeit‑Token‑Streaming.

Schnellstart

5 Minuten

Starten Sie in drei Schritten. Shannon spiegelt OpenAI‑ und Anthropic‑Clients.

Basis‑URL festlegen

Verwenden Sie den OpenAI‑kompatiblen Endpunkt.

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

API‑Schlüssel hinzufügen

Verwenden Sie Bearer‑Auth im Authorization‑Header.

Erste Nachricht senden

Wählen Sie eine Sprache und ersetzen Sie durch Ihren Schlüssel.

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

Antwortformat

Erfolgsantwort

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

Neu

Testen Sie die Shannon‑API direkt im Browser. Bauen Sie Ihre Anfrage, führen Sie sie aus und sehen Sie die Antwort in Echtzeit.

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.

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

Playground testen V2 API‑Schlüssel erhalten

Authentifizierung

Alle API-Anfragen erfordern Authentifizierung mit deinem Shannon-API-Schlüssel.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic‑Format

HTTP

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

Modelle

Shannon bietet mehrere Modelle, optimiert für unterschiedliche Anwendungsfälle.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Kontext 128K

Am besten für Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Kontext 128K

Am besten für Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Kontext 128K

Am besten für

shannon-2-pro Shannon 2 Pro

Kontext 128K

Am besten für

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Kontext 128K

Am besten für Code Generation, Tool Use, CLI Integration

Call-based quota

Funktionsaufrufe

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

Optionen zur Werkzeugauswahl

"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

Antwort auf Funktionsaufruf

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

Strukturierte Ausgaben

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

Optionen für Antwortformat

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

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

Integrierte Websuche

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

Profi-Tipp: Websuche-Ergebnisse enthalten Quellenangaben. Shannon zitiert Quellen automatisch.

Anthropic‑Format

Shannon unterstützt auch das Messages-API-Format von Anthropic.

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

Erforderlicher Header: Anthropic format requires anthropic-version: 2023-06-01.

SDKs

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

Fehlerbehandlung

Shannon verwendet standardmäßige HTTP‑Statuscodes und liefert detaillierte Fehlermeldungen.

400 Ungültige Anfrage Ungültiges Anfrageformat oder Parameter

401 Nicht autorisiert Ungültiger oder fehlender API‑Schlüssel

402 Kontingent überschritten Token‑ oder Suchkontingent überschritten

429 Rate‑begrenzt Zu viele Anfragen, bitte langsamer

500 Serverfehler Interner Fehler, später erneut versuchen

Fehlerantwort‑Format

Fehlerantwort

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

Changelog

LOG

Recent updates and improvements to the Shannon API.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

Ihr API‑Schlüssel

Access

Nutze Bearer für OpenAI oder X-API-Key + anthropic-version.

YOUR_API_KEY

API‑Schlüssel erhalten

Halten Sie Ihren API‑Schlüssel geheim. Eine Regenerierung erstellt einen neuen Schlüssel und macht den alten ungültig.

Ihre Nutzung

Sieh Token- und Suchverbrauch auf dieser Seite nach dem Login.

-- API‑Aufrufe

-- Verbrauchte Tokens

Shannon API

Überblick

Funktionen

Direkter Ersatz

Funktionsaufrufe

Integrierte Websuche

Strukturierte Ausgaben

Multi‑Turn‑Tools

Streaming

Schnellstart

Basis‑URL festlegen

API‑Schlüssel hinzufügen

Erste Nachricht senden

Antwortformat

API‑Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Authentifizierung

OpenAI Format (Recommended)

Anthropic‑Format

Modelle

Funktionsaufrufe

Optionen zur Werkzeugauswahl

Antwort auf Funktionsaufruf

Strukturierte Ausgaben

Optionen für Antwortformat

Streaming

Integrierte Websuche

Anthropic‑Format

SDKs

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Fehlerbehandlung

Fehlerantwort‑Format

Changelog

Ihr API‑Schlüssel

Ihre Nutzung

Shannon Coder (shannon-coder-1)

Bereit zum Bauen?

Shannon AI API Documentation

Überblick

Funktionen

Direkter Ersatz

Funktionsaufrufe

Integrierte Websuche

Strukturierte Ausgaben

Multi‑Turn‑Tools

Streaming

Schnellstart

Basis‑URL festlegen

API‑Schlüssel hinzufügen

Erste Nachricht senden

Antwortformat

API‑Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Authentifizierung

OpenAI Format (Recommended)

Anthropic‑Format

Modelle

Funktionsaufrufe

Optionen zur Werkzeugauswahl

Antwort auf Funktionsaufruf

Strukturierte Ausgaben

Optionen für Antwortformat

Streaming

Integrierte Websuche

Anthropic‑Format

SDKs

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Fehlerbehandlung

Fehlerantwort‑Format

Changelog

Ihr API‑Schlüssel

Ihre Nutzung

Shannon Coder (shannon-coder-1)

Bereit zum Bauen?