Documentazione API Shannon AI

Panoramica

Docs pubblici

Tutto ciò che serve per rilasciare con l'API compatibile OpenAI e Anthropic di Shannon.

URL base Compatibile con OpenAI

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

Usa la Chat Completions API con function calling e streaming.

URL base Compatibile con Anthropic

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

Formato Claude Messages con tools e header anthropic-version.

Intestazioni Autenticazione

Autorizzazione: Bearer <la-tua-chiave>

Oppure usa X-API-Key con anthropic-version per chiamate in stile Claude.

Access Status

Public docs - Key required to call

Streaming, function calling, output strutturati e ricerca web.

Checklist di lancio

+

Punta il tuo SDK a Shannon

Imposta baseURL all'endpoint OpenAI o Anthropic qui sopra.

Setup
+

Aggiungi la tua chiave API

Usa Bearer per OpenAI o X-API-Key + anthropic-version.

Security
+

Abilita tools e output strutturati

Supporta tools/functions OpenAI, JSON schema e web_search integrato.

Funzionalità
+

Monitora l'utilizzo

Visualizza consumo token e ricerche in questa pagina dopo il login.

Analytics

Funzionalità

OpenAI + Anthropic

Sostituzione diretta delle API OpenAI e Anthropic con supporto nativo per tools, output strutturati e ricerca web.

Sostituzione diretta

Compatibile

Funziona con gli SDK OpenAI e Anthropic. Basta cambiare la base URL.

Chiamate di funzione

Strumenti

Definisci strumenti e lascia che Shannon li chiami. Supporta modalità auto, forzata e nessuna.

Ricerca web integrata

Ricerca

Ricerca web in tempo reale con citazioni delle fonti. Disponibile automaticamente.

Output strutturati

JSON

Modalità JSON e applicazione di JSON Schema per estrazione dati affidabile.

Strumenti multi‑turno

Agentico

Loop automatici di esecuzione funzioni. Fino a 10 iterazioni per richiesta.

Streaming

Rapido

Server‑Sent Events per lo streaming di token in tempo reale.

Avvio rapido

5 minuti

Inizia in tre passaggi. Shannon rispecchia i client OpenAI e Anthropic.

Imposta la base URL

Usa l’endpoint compatibile con OpenAI.

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

Aggiungi la tua chiave API

Usa l’autenticazione Bearer nell’header Authorization.

Invia il tuo primo messaggio

Scegli una lingua e sostituisci con la tua chiave.

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

Formato di risposta

Risposta riuscita

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

Playground API

Nuovo

Prova l’API Shannon direttamente nel browser. Costruisci la richiesta, eseguila e vedi la risposta in tempo reale.

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.

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

Prova Playground V2 Ottieni chiave API

Autenticazione

Tutte le richieste API richiedono autenticazione con la tua chiave API Shannon.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Formato Anthropic

HTTP

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

Modelli

Shannon offre più modelli ottimizzati per diversi casi d'uso.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Contesto 128K

Ideale per Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Contesto 128K

Ideale per Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Contesto 128K

Ideale per

shannon-2-pro Shannon 2 Pro

Contesto 128K

Ideale per

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Contesto 128K

Ideale per Code Generation, Tool Use, CLI Integration

Call-based quota

Chiamata di funzioni

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

Opzioni di scelta dello strumento

"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

Risposta alla chiamata di funzione

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

Output strutturati

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

Opzioni formato risposta

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

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

Ricerca web integrata

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

Suggerimento pro: I risultati web includono citazioni. Shannon citerà automaticamente le fonti.

Formato Anthropic

Shannon supporta anche il formato Messages API di 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);

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

SDK

Compatibile

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

Gestione errori

Shannon usa codici di stato HTTP standard e restituisce messaggi di errore dettagliati.

400 Richiesta non valida Formato o parametri della richiesta non validi

401 Non autorizzato Chiave API mancante o non valida

402 Quota superata Quota token o ricerca superata

429 Limite di rate Troppe richieste, rallenta

500 Errore del server Errore interno, riprova più tardi

Formato risposta errore

Risposta di errore

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

Registro modifiche

LOG

Recent updates and improvements to the Shannon API.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

La tua chiave API

Access

Usa Bearer per OpenAI o X-API-Key + anthropic-version.

YOUR_API_KEY

Ottieni chiave API

Mantieni segreta la tua chiave API. Rigenerare crea una nuova chiave e invalida quella precedente.

Il tuo utilizzo

Visualizza consumo token e ricerche in questa pagina dopo il login.

-- Chiamate API

-- Token usati

API Shannon

Panoramica

Funzionalità

Sostituzione diretta

Chiamate di funzione

Ricerca web integrata

Output strutturati

Strumenti multi‑turno

Streaming

Avvio rapido

Imposta la base URL

Aggiungi la tua chiave API

Invia il tuo primo messaggio

Formato di risposta

Playground API

Chat, Responses, Messages

Stream live output

Reuse your key

Autenticazione

OpenAI Format (Recommended)

Formato Anthropic

Modelli

Chiamata di funzioni

Opzioni di scelta dello strumento

Risposta alla chiamata di funzione

Output strutturati

Opzioni formato risposta

Streaming

Ricerca web integrata

Formato Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Gestione errori

Formato risposta errore

Registro modifiche

La tua chiave API

Il tuo utilizzo

Shannon Coder (shannon-coder-1)

Pronto a costruire?

Shannon AI API Documentation

Panoramica

Funzionalità

Sostituzione diretta

Chiamate di funzione

Ricerca web integrata

Output strutturati

Strumenti multi‑turno

Streaming

Avvio rapido

Imposta la base URL

Aggiungi la tua chiave API

Invia il tuo primo messaggio

Formato di risposta

Playground API

Chat, Responses, Messages

Stream live output

Reuse your key

Autenticazione

OpenAI Format (Recommended)

Formato Anthropic

Modelli

Chiamata di funzioni

Opzioni di scelta dello strumento

Risposta alla chiamata di funzione

Output strutturati

Opzioni formato risposta

Streaming

Ricerca web integrata

Formato Anthropic

SDK

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Gestione errori

Formato risposta errore

Registro modifiche

La tua chiave API

Il tuo utilizzo

Shannon Coder (shannon-coder-1)

Pronto a costruire?