Shannon AI API‑dokumentation

Oversikt

Offentlige docs

Alt du trenger for å lansere med Shannons OpenAI- og Anthropic‑kompatible API.

Basis-URL OpenAI-kompatibel

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

Bruk Chat Completions API med function calling og streaming.

Basis-URL Anthropic-kompatibel

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

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

Overskrifter Autentisering

Autorisasjon: Bearer <din-noekkel>

Eller bruk X-API-Key med anthropic-version for kall i Claude-stil.

Access Status

Public docs - Key required to call

Streaming, function calling, strukturerte svar og nettsøk.

Lanseringssjekkliste

+

Pek SDK-et ditt til Shannon

Sett baseURL til OpenAI- eller Anthropic-endepunktet over.

Setup
+

Legg til API-nøkkelen din

Bruk Bearer for OpenAI eller X-API-Key + anthropic-version.

Security
+

Aktiver tools og strukturerte svar

Støtter OpenAI tools/functions, JSON schema og innebygd web_search.

Funksjoner
+

Følg bruk

Se token- og søkeforbruk på denne siden når du er innlogget.

Analytics

Funksjoner

OpenAI + Anthropic

Direkte erstatning for OpenAI- og Anthropic-API-er med innebygd støtte for tools, strukturerte svar og nettsøk.

Drop‑in‑erstatning

Kompatibel

Fungerer med OpenAI- og Anthropic‑SDK-er. Bare endre base‑URL.

Funksjonskall

Verktøy

Definer verktøy, la Shannon kalle dem. Støtter auto, forced og none‑modus.

Innebygd nettesøk

Søk

Sanntids nettesøk med kildehenvisninger. Tilgjengelig automatisk.

Strukturerte utdata

JSON

JSON‑modus og håndheving av JSON‑skjema for pålitelig datauttrekk.

Flertrinnsverktøy

Agentisk

Automatiske funksjonskjørings‑sløyfer. Opptil 10 iterasjoner per forespørsel.

Strømming

Rask

Server‑sent events for sanntids token‑streaming.

Hurtigstart

5 minutter

Kom i gang i tre trinn. Shannon speiler OpenAI- og Anthropic‑klienter.

Sett base‑URL

Bruk OpenAI‑kompatibelt endepunkt.

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

Legg til API‑nøkkel

Bruk Bearer‑autentisering i Authorization‑header.

Send din første melding

Velg språk og sett inn nøkkelen din.

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

Vellykket 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‑lekeplass

Test Shannon API direkte i nettleseren. Bygg forespørselen, kjør den og se svaret i sanntid.

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.

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

Prøv Playground V2 Få API-nøkkel

Autentisering

Alle API-kall krever autentisering med Shannon API-nøkkel.

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 tilbyr flere modeller optimalisert for ulike bruksområder.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Kontekst 128K

Best for Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Kontekst 128K

Best for Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Kontekst 128K

Best for

shannon-2-pro Shannon 2 Pro

Kontekst 128K

Best for

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Kontekst 128K

Best for Code Generation, Tool Use, CLI Integration

Call-based quota

Funksjonskall

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

Verktøyvalg-alternativer

"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å funksjonskall

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

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

Alternativer for svarformat

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

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

Strømming

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.

Innebygd websøk

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

Profftips: Nettsøkresultater inkluderer kilder. Shannon siterer kilder automatisk.

Anthropic-format

Shannon støtter også 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);

Påkrevd header: 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-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 ->

Feilhåndtering

Shannon bruker standard HTTP‑statuskoder og returnerer detaljerte feil.

400 Ugyldig forespørsel Ugyldig forespørselsformat eller parametere

401 Uautorisert Ugyldig eller manglende API‑nøkkel

402 Kvoten er overskredet Token- eller søkekvote overskredet

429 Rate‑begrenset For mange forespørsler, ro ned

500 Serverfeil Intern feil, prøv igjen senere

Feilsvarformat

Feilsvar

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

Endringslogg

LOG

Recent updates and improvements to the Shannon API.

v2.2.0

2026-03-28

Ny Claude Code support — use Shannon as your Anthropic backend for the official CLI coding agent
Ny 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

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‑nøkkel

Access

Bruk Bearer for OpenAI eller X-API-Key + anthropic-version.

YOUR_API_KEY

Få API-nøkkel

Hold API‑nøkkelen hemmelig. Regenerering lager en ny nøkkel og ugyldiggjør den gamle.

Din bruk

Se token- og søkeforbruk på denne siden når du er innlogget.

-- API‑kall

-- Brukte tokens

Shannon AI API Documentation

Oversikt

Funksjoner

Drop‑in‑erstatning

Funksjonskall

Innebygd nettesøk

Strukturerte utdata

Flertrinnsverktøy

Strømming

Hurtigstart

Sett base‑URL

Legg til API‑nøkkel

Send din første melding

Svarformat

API‑lekeplass

Chat, Responses, Messages

Stream live output

Reuse your key

Autentisering

OpenAI Format (Recommended)

Anthropic-format

Modeller

Funksjonskall

Verktøyvalg-alternativer

Svar på funksjonskall

Strukturerte utdata

Alternativer for svarformat

Strømming

Innebygd websøk

Anthropic-format

CLI Coding Agents

Claude Code

Codex CLI

SDK-er

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Feilhåndtering

Feilsvarformat

Endringslogg

Din API‑nøkkel

Din bruk

Shannon Coder (shannon-coder-1)

Klar til å bygge?