Documentație API Shannon AI

Prezentare generală

Documente publice

Tot ce ai nevoie pentru a lansa cu API‑ul Shannon compatibil OpenAI și Anthropic.

URL de bază Compatibil cu OpenAI

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

Folosește Chat Completions API cu function calling și streaming.

URL de bază Compatibil cu Anthropic

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

Format Claude Messages cu tools și header anthropic-version.

Antete Autentificare

Autorizare: Bearer <cheia-ta>

Sau folosește X-API-Key cu anthropic-version pentru apeluri în stil Claude.

Access Status

Public docs - Key required to call

Streaming, function calling, output-uri structurate și căutare web.

Checklist de lansare

+

Direcționează SDK-ul tău către Shannon

Setează baseURL către endpoint-ul OpenAI sau Anthropic de mai sus.

Setup
+

Adaugă cheia ta API

Folosește Bearer pentru OpenAI sau X-API-Key + anthropic-version.

Security
+

Activează tools și output-uri structurate

Suportă OpenAI tools/functions, JSON schema și web_search integrat.

Capabilități
+

Monitorizează utilizarea

Vezi consumul de tokenuri și căutări pe această pagină după autentificare.

Analytics

Capabilități

OpenAI + Anthropic

Înlocuitor direct pentru API-urile OpenAI și Anthropic cu suport nativ pentru tools, output-uri structurate și căutare web.

Înlocuire drop‑in

Compatibil

Funcționează cu SDK‑urile OpenAI și Anthropic. Doar schimbă URL‑ul de bază.

Apelare de funcții

Instrumente

Definește instrumente, lasă Shannon să le apeleze. Suportă modurile auto, forțat și niciunul.

Căutare web integrată

Căutare

Căutare web în timp real cu citări de surse. Disponibil automat.

Ieșiri structurate

JSON

Mod JSON și impunerea schemei JSON pentru extragere fiabilă a datelor.

Instrumente multi‑tur

Agentic

Bucle automate de execuție a funcțiilor. Până la 10 iterații pe cerere.

Streaming

Rapid

Evenimente SSE pentru streaming de tokeni în timp real.

Pornire rapidă

5 minute

Începe în trei pași. Shannon oglindește clienții OpenAI și Anthropic.

Setează URL‑ul de bază

Folosește endpointul compatibil cu OpenAI.

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

Adaugă cheia API

Folosește autentificarea Bearer în antetul Authorization.

Trimite primul mesaj

Alege o limbă și înlocuiește cu cheia ta.

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

Format răspuns

Răspuns de succes

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

Nou

Testează API‑ul Shannon direct în browser. Construiește cererea, ruleaz‑o și vezi răspunsul în timp real.

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.

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

Încearcă Playground V2 Obține cheia API

Autentificare

Toate cererile API necesită autentificare cu cheia ta API Shannon.

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

Format Anthropic

HTTP

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

Modele

Shannon oferă mai multe modele optimizate pentru diferite cazuri de utilizare.

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

Context 128K

Cel mai bun pentru Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

Context 128K

Cel mai bun pentru Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

Context 128K

Cel mai bun pentru

shannon-2-pro Shannon 2 Pro

Context 128K

Cel mai bun pentru

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

Context 128K

Cel mai bun pentru Code Generation, Tool Use, CLI Integration

Call-based quota

Apelare funcții

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

Opțiuni de alegere a instrumentului

"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

Răspuns apel funcție

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

Rezultate structurate

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

Opțiuni format răspuns

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

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

Căutare web integrată

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

Sfat pro: Rezultatele căutării web includ citări. Shannon va cita automat sursele.

Format Anthropic

Shannon suportă și formatul Anthropic Messages API.

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 obligatoriu: Anthropic format requires anthropic-version: 2023-06-01.

SDK-uri

Compatibil

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

Gestionare erori

Shannon folosește coduri standard HTTP și returnează mesaje detaliate.

400 Cerere invalidă Format de cerere sau parametri invalizi

401 Neautorizat Cheie API invalidă sau lipsă

402 Cota depășită Cota de tokeni sau căutări a fost depășită

429 Limită de rată Prea multe cereri, încetinește

500 Eroare de server Eroare internă, încearcă mai târziu

Format răspuns eroare

Răspuns de eroare

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

Jurnal de modificări

LOG

Recent updates and improvements to the Shannon API.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

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

v1.0.0

2024-10-01

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

Cheia ta API

Access

Folosește Bearer pentru OpenAI sau X-API-Key + anthropic-version.

YOUR_API_KEY

Obține cheia API

Păstrează cheia API secretă. Regenerarea creează o cheie nouă și o invalidează pe cea veche.

Utilizarea ta

Vezi consumul de tokenuri și căutări pe această pagină după autentificare.

-- Apeluri API

-- Tokeni folosiți

API Shannon

Prezentare generală

Capabilități

Înlocuire drop‑in

Apelare de funcții

Căutare web integrată

Ieșiri structurate

Instrumente multi‑tur

Streaming

Pornire rapidă

Setează URL‑ul de bază

Adaugă cheia API

Trimite primul mesaj

Format răspuns

Playground API

Chat, Responses, Messages

Stream live output

Reuse your key

Autentificare

OpenAI Format (Recommended)

Format Anthropic

Modele

Apelare funcții

Opțiuni de alegere a instrumentului

Răspuns apel funcție

Rezultate structurate

Opțiuni format răspuns

Streaming

Căutare web integrată

Format Anthropic

SDK-uri

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Gestionare erori

Format răspuns eroare

Jurnal de modificări

Cheia ta API

Utilizarea ta

Shannon Coder (shannon-coder-1)

Gata să construiești?

Shannon AI API Documentation

Prezentare generală

Capabilități

Înlocuire drop‑in

Apelare de funcții

Căutare web integrată

Ieșiri structurate

Instrumente multi‑tur

Streaming

Pornire rapidă

Setează URL‑ul de bază

Adaugă cheia API

Trimite primul mesaj

Format răspuns

Playground API

Chat, Responses, Messages

Stream live output

Reuse your key

Autentificare

OpenAI Format (Recommended)

Format Anthropic

Modele

Apelare funcții

Opțiuni de alegere a instrumentului

Răspuns apel funcție

Rezultate structurate

Opțiuni format răspuns

Streaming

Căutare web integrată

Format Anthropic

SDK-uri

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

Gestionare erori

Format răspuns eroare

Jurnal de modificări

Cheia ta API

Utilizarea ta

Shannon Coder (shannon-coder-1)

Gata să construiești?