Documentatio API Shannon AI

Conspectus

Public docs

Omnia quae opus sunt ad emittere cum API Shannon compatibili OpenAI et Anthropic.

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 Authenticatio

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.

Facultates
+

Track usage

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

Analytics

Facultates

OpenAI + Anthropic

Substitutum drop‑in pro APIis OpenAI et Anthropic cum auxilio instrumentorum, exitibus structis et quaesitu interretiali incorporato.

Substitutio drop‑in

Compatibile

Cum SDK OpenAI et Anthropic operatur. Tantum URL basem muta.

Vocatio functionum

Instrumenta

Instrumenta define, sinas Shannon ea vocare. Modos auto, forced et none sustinet.

Investigatio web incorporata

Quaerere

Investigatio web in tempore reali cum citationibus fontium. Automatice praesto.

Exitus structi

JSON

Modus JSON et coercitio JSON Schema ad extractionem datorum fidam.

Instrumenta plurium vicium

Agenticum

Gyri executionis functionum automaticae. Usque ad 10 iterationes per petitionem.

Fluxus

Celer

Server‑sent events ad fluxum tokenum in tempore reali.

Initium celer

5 minuta

In tribus gradibus incipi. Shannon clientes OpenAI et Anthropic imitatur.

URL basem constitue

Endpointum OpenAI‑compatibile utere.

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

Clavem API tuam adde

Bearer auth in capite Authorization utere.

Primum nuntium mitte

Linguam elige et clavem tuam insere.

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

Forma responsi

Responsum prosperum

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

Locus API

Novum

API Shannon in navigatro directe experire. Petitionem compone, curre, et responsum reali tempore vide.

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.

/la/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 experire V2 Clave API tuum obtine

Authenticatio

Omnes petitiones API authentications exigunt per clavem API Shannon tuam.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic

HTTP

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

Modelli

Shannon plura exemplaria ad diversos usus optima offert.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Contextus 128K

Aedificatum pro Professionalibus Securitatis Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Contextus 128K

Aedificatum pro Professionalibus Securitatis Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Contextus 128K

Aedificatum pro Professionalibus Securitatis

shannon-2-pro Shannon 2 Pro

Contextus 128K

Aedificatum pro Professionalibus Securitatis

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Contextus 128K

Aedificatum pro Professionalibus Securitatis Code Generation, Tool Use, CLI Integration

Call-based quota

Vocatio functionum

Define instrumenta quae Shannon vocare potest ad actiones perficiendas vel informationem recipiendam.

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

Vocatio functionum

"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

Forma responsi

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

Exitus structi

Coge Shannon respondere cum valido JSON quod schemati tuo congruit.

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

Forma responsi

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

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

Fluens

Activa fluxum tokenorum in tempore reali per Server‑Sent Events ad UI responsivas.

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.

Quaestus interretialis

Shannon includit functionem web_search incorporatam quae automatice praesto est.

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

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

Anthropic

Shannon etiam formatum Messages API Anthropic sustinet.

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

Compatibile

Utere quovis SDK OpenAI vel Anthropic — solum base URL muta.

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

Tractatio errorum

Shannon codices status HTTP standardes utitur et errores accuratos reddit.

400 Petitio mala Forma petitionis vel parametri invalida

401 Non auctoratus Clavis API invalida vel deest

402 Quota superata Quota tokenum vel quaestionis superata

429 Limitatio celeritatis Nimiae petitiones, lente

500 Error serveris Error internus, postea tenta

Forma responsi erroris

Responsum erroris

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

Acta mutationum

LOG

Recentes renovationes et emendationes ad Shannon API.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

Clavis API tua

Access

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

YOUR_API_KEY

Clave API tuum obtine

Clavem API secretam tene. Regeneratio clavem novam creat et veterem irritat.

Usus tuus

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

-- Appellationes API

-- Tokenes usi

Shannon API

Conspectus

Facultates

Substitutio drop‑in

Vocatio functionum

Investigatio web incorporata

Exitus structi

Instrumenta plurium vicium

Fluxus

Initium celer

URL basem constitue

Clavem API tuam adde

Primum nuntium mitte

Forma responsi

Locus API

Chat, Responses, Messages

Stream live output

Reuse your key

Authenticatio

OpenAI Format (Recommended)

Anthropic

Modelli

Vocatio functionum

Vocatio functionum

Forma responsi

Exitus structi

Forma responsi

Fluens

Quaestus interretialis

Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Tractatio errorum

Forma responsi erroris

Acta mutationum

Clavis API tua

Usus tuus

Shannon Coder (shannon-coder-1)

Paratus ad aedificandum?

Shannon AI API Documentation

Conspectus

Facultates

Substitutio drop‑in

Vocatio functionum

Investigatio web incorporata

Exitus structi

Instrumenta plurium vicium

Fluxus

Initium celer

URL basem constitue

Clavem API tuam adde

Primum nuntium mitte

Forma responsi

Locus API

Chat, Responses, Messages

Stream live output

Reuse your key

Authenticatio

OpenAI Format (Recommended)

Anthropic

Modelli

Vocatio functionum

Vocatio functionum

Forma responsi

Exitus structi

Forma responsi

Fluens

Quaestus interretialis

Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Tractatio errorum

Forma responsi erroris

Acta mutationum

Clavis API tua

Usus tuus

Shannon Coder (shannon-coder-1)

Paratus ad aedificandum?