Shannon AI API Dokumentáció

Áttekintés

Nyilvános dokumentumok

Minden, amire szükséged van a Shannon OpenAI/Anthropic kompatibilis API-jával való induláshoz.

Alap URL OpenAI‑kompatibilis

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

Használd a Chat Completions API-t függvényhívással és streameléssel.

Alap URL Anthropic‑kompatibilis

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

Claude Messages formátum eszközökkel és anthropic-version fejléccel.

Fejlécek Hitelesítés

Hitelesítés: Bearer <kulcsod>

Vagy X-API-Key anthropic-versionnel a Claude‑stílusú hívásokhoz.

Hozzáférés Állapot

Nyilvános dokumentumok – kulcs szükséges a híváshoz

Streaming, függvényhívás, strukturált kimenetek, webes keresés.

Indítási ellenőrzőlista

+

Irányítsd az SDK‑t a Shannonra

Állítsd a baseURL‑t a fenti OpenAI vagy Anthropic végpontokra.

Beállítás
+

Csatold az API‑kulcsodat

Használj Bearer tokent az OpenAI hívásokhoz vagy X-API-Key + anthropic-version.

Biztonság
+

Eszközök és strukturált kimenetek engedélyezése

Támogatja az OpenAI eszközöket/funkciókat, JSON sémát és a beépített web_search-t.

Képességek
+

Használat követése

Nézd meg a token- és keresési fogyasztást ezen az oldalon, ha be vagy jelentkezve.

Analitika

Képességek

OpenAI + Anthropic

Drop‑in helyettesítés az OpenAI és Anthropic API-khoz, natív eszköz-, strukturált kimenet- és beépített webes keresés támogatással.

Drop‑in helyettesítés

Kompatibilis

Működik az OpenAI és Anthropic SDK-kkal. Csak a base URL-t kell módosítani.

Függvényhívás

Eszközök

Definiálj eszközöket, a Shannon meghívja őket. Támogatja az auto, forced és none módot.

Beépített webes keresés

Keresés

Valós idejű webes keresés forrás‑hivatkozásokkal. Automatikusan elérhető.

Strukturált kimenetek

JSON

JSON mód és JSON Schema kényszerítés megbízható adatkivonáshoz.

Többfordulós eszközök

Agentikus

Automatikus függvény‑végrehajtási ciklusok. Kérésenként akár 10 iteráció.

Streaming

Gyors

Server‑sent events a valós idejű token‑streameléshez.

Gyors kezdés

5 perc

Indulj három lépésben. Shannon tükrözi az OpenAI és Anthropic klienseket.

Állítsd be a base URL‑t

Használd az OpenAI‑kompatibilis végpontot.

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

Add hozzá az API‑kulcsodat

Használd a Bearer hitelesítést az Authorization fejlécben.

Küldd el az első üzeneted

Válassz nyelvet és cseréld be a kulcsodat.

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

Válaszformátum

Sikeres válasz

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

Új

Teszteld a Shannon API-t közvetlenül a böngészőben. Készíts kérést, futtasd és nézd a választ valós időben.

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.

/hu/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 kipróbálása V2 API‑kulcs kérése

Hitelesítés

Minden API‑kérés hitelesítést igényel a Shannon API‑kulcsoddal.

OpenAI formátum (ajánlott)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic formátum

HTTP

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

Modellek

A Shannon több modellt kínál különböző felhasználásokhoz optimalizálva.

shannon-1.6-lite Shannon 1.6 Lite

Gyors, hatékony válaszok mindennapi feladatokra

Kontekstus 128K

Legjobb ehhez Chat, Kérdések és válaszok, Tartalomkészítés

shannon-1.6-pro Shannon 1.6 Pro

Fejlett érvelés összetett problémákhoz

Kontekstus 128K

Legjobb ehhez Elemzés, Kutatás, Összetett feladatok

shannon-2-lite Shannon 2 Lite

Kontekstus 128K

Legjobb ehhez

shannon-2-pro Shannon 2 Pro

Kontekstus 128K

Legjobb ehhez

shannon-coder-1 Shannon Coder

Optimalizálva a Claude Code CLI-hez hívás alapú kvótával

Kontekstus 128K

Legjobb ehhez Kódgenerálás, Eszközhasználat, CLI integráció

Hívás alapú kvóta

Funkcióhívás

Definiálj eszközöket, amelyeket a Shannon meghívhat műveletek végrehajtására vagy információ lekérésére.

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

Eszközválasztási lehetőségek

"auto" A modell eldönti, hív-e függvényt (alapértelmezett)

"none" Függvényhívás letiltása ehhez a kéréshez

{"type": "function", "function": {"name": "..."}} Egy adott függvényhívás kikényszerítése

Függvényhívás válasza

Amikor a modell függvényt hív

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

Strukturált kimenetek

Kényszerítsd a Shannont, hogy érvényes JSON-nal válaszoljon, amely megfelel a sémádnak.

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

Válaszformátum lehetőségek

{"type": "json_object"} Érvényes JSON kimenet kikényszerítése (nincs konkrét séma)

{"type": "json_schema", "json_schema": {...}} Kimenet kikényszerítése, amely megfelel a pontos sémádnak

Streaming

Valós idejű token‑streamelés Server‑Sent Events segítségével reszponzív felületekhez.

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: A streaming válaszok Server‑Sent Events formában érkeznek. Minden chunk egy delta‑t tartalmaz részleges tartalommal.

Beépített webes keresés

A Shannon tartalmaz egy beépített web_search funkciót, amely automatikusan elérhető.

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

Pro tipp: A webes keresési találatok hivatkozásokat tartalmaznak. A Shannon automatikusan idézi a forrásokat.

Anthropic formátum

A Shannon az Anthropic Messages API formátumát is támogatja.

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

Kötelező fejléc: Az Anthropic formátumhoz anthropic-version: 2023-06-01 szükséges.

SDK-k

Kompatibilis

Használj bármilyen OpenAI vagy Anthropic SDK-t – csak a base URL-t kell módosítani.

OpenAI‑kompatibilis SDK-k

SDK Python

Hivatalos OpenAI Python SDK – működik a Shannonnal

pip install openai

Dokumentáció megtekintése ->

SDK JavaScript / TypeScript

Hivatalos OpenAI Node.js SDK – működik a Shannonnal

npm install openai

Dokumentáció megtekintése ->

SDK Go

Közösségi Go kliens OpenAI‑kompatibilis API-khoz

go get github.com/sashabaranov/go-openai

Dokumentáció megtekintése ->

SDK Ruby

Közösségi Ruby kliens OpenAI‑kompatibilis API-khoz

gem install ruby-openai

Dokumentáció megtekintése ->

SDK PHP

Közösségi PHP kliens OpenAI‑kompatibilis API-khoz

composer require openai-php/client

Dokumentáció megtekintése ->

SDK Rust

Aszinkron Rust kliens OpenAI‑kompatibilis API-khoz

cargo add async-openai

Dokumentáció megtekintése ->

Anthropic‑kompatibilis SDK-k

SDK Python (Anthropic)

Hivatalos Anthropic Python SDK – működik a Shannonnal

pip install anthropic

Dokumentáció megtekintése ->

SDK TypeScript (Anthropic)

Hivatalos Anthropic TypeScript SDK – működik a Shannonnal

npm install @anthropic-ai/sdk

Dokumentáció megtekintése ->

Hibakezelés

A Shannon szabványos HTTP státuszkódokat használ, és részletes hibaüzeneteket ad vissza.

400 Hibás kérés Érvénytelen kérésformátum vagy paraméterek

401 Nem jogosult Érvénytelen vagy hiányzó API‑kulcs

402 Kvóta túllépve Token‑ vagy keresési kvóta túllépve

429 Korlátozott sebesség Túl sok kérés, lassíts

500 Szerverhiba Belső hiba, próbáld később

Hibaválasz formátuma

Hibaválasz

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

Változásnapló

LOG

Legutóbbi frissítések és fejlesztések a Shannon API-hoz.

v2.1.0

2025-01-03

Új Hozzáadva a shannon-coder-1 modell a Claude Code CLI integrációhoz
Új Hívásalapú kvótarendszer a Coder modellhez
Fejlesztve A függvényhívás megbízhatóságának javítása

v2.0.0

2024-12-15

Új Anthropic Messages API kompatibilitás hozzáadva
Új Többfordulós eszközvégrehajtás (akár 10 iteráció)
Új JSON Schema válaszformátum támogatás
Fejlesztve Webes keresés javítva jobb hivatkozásokkal

v1.5.0

2024-11-20

Új Hozzáadva a shannon-deep-dapo modell összetett érveléshez
Új Beépített web_search funkció
Fejlesztve Csökkentett késleltetés a streaming válaszoknál

v1.0.0

2024-10-01

Új Az API kezdeti kiadása
Új OpenAI‑kompatibilis chat completions végpont
Új Függvényhívás támogatás
Új Streaming Server‑Sent Events-en keresztül

API‑kulcsod

Hozzáférés

Használj Bearer tokent az OpenAI hívásokhoz vagy X-API-Key + anthropic-version.

YOUR_API_KEY

API‑kulcs kérése

Tartsd titokban az API‑kulcsodat. Az újragenerálás új kulcsot hoz létre és érvényteleníti a régit.

Használatod

Nézd meg a token- és keresési fogyasztást ezen az oldalon, ha be vagy jelentkezve.

-- API‑hívások

-- Felhasznált tokenek

Shannon API

Áttekintés

Képességek

Drop‑in helyettesítés

Függvényhívás

Beépített webes keresés

Strukturált kimenetek

Többfordulós eszközök

Streaming

Gyors kezdés

Állítsd be a base URL‑t

Add hozzá az API‑kulcsodat

Küldd el az első üzeneted

Válaszformátum

Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Hitelesítés

OpenAI formátum (ajánlott)

Anthropic formátum

Modellek

Funkcióhívás

Eszközválasztási lehetőségek

Függvényhívás válasza

Strukturált kimenetek

Válaszformátum lehetőségek

Streaming

Beépített webes keresés

Anthropic formátum

SDK-k

OpenAI‑kompatibilis SDK-k

Anthropic‑kompatibilis SDK-k

Hibakezelés

Hibaválasz formátuma

Változásnapló

API‑kulcsod

Használatod

Shannon Coder (shannon-coder-1)

Készen állsz a fejlesztésre?

Shannon AI API Documentation

Áttekintés

Képességek

Drop‑in helyettesítés

Függvényhívás

Beépített webes keresés

Strukturált kimenetek

Többfordulós eszközök

Streaming

Gyors kezdés

Állítsd be a base URL‑t

Add hozzá az API‑kulcsodat

Küldd el az első üzeneted

Válaszformátum

Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Hitelesítés

OpenAI formátum (ajánlott)

Anthropic formátum

Modellek

Funkcióhívás

Eszközválasztási lehetőségek

Függvényhívás válasza

Strukturált kimenetek

Válaszformátum lehetőségek

Streaming

Beépített webes keresés

Anthropic formátum

SDK-k

OpenAI‑kompatibilis SDK-k

Anthropic‑kompatibilis SDK-k

Hibakezelés

Hibaválasz formátuma

Változásnapló

API‑kulcsod

Használatod

Shannon Coder (shannon-coder-1)

Készen állsz a fejlesztésre?