เอกสาร API ของ Shannon AI

ภาพรวม

เอกสารสาธารณะ

ทุกอย่างที่คุณต้องการเพื่อใช้งาน API ของ Shannon ที่เข้ากันได้กับ OpenAI และ Anthropic.

URL พื้นฐาน รองรับ OpenAI

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

ใช้ Chat Completions API พร้อม function calling และ streaming

URL พื้นฐาน รองรับ Anthropic

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

รูปแบบ Claude Messages พร้อม tools และ header anthropic-version

ส่วนหัว การยืนยันตัวตน

การยืนยันสิทธิ์: Bearer <your-key-th>

หรือใช้ X-API-Key + anthropic-version สำหรับคำขอสไตล์ Claude

Access Status

Public docs - Key required to call

Streaming, function calling, เอาต์พุตแบบมีโครงสร้าง และเว็บเสิร์ช

เช็กลิสต์การเปิดใช้งาน

+

ชี้ SDK ของคุณไปที่ Shannon

ตั้งค่า baseURL ไปยัง endpoint ของ OpenAI หรือ Anthropic ด้านบน

Setup
+

เพิ่ม API key ของคุณ

ใช้ Bearer สำหรับ OpenAI หรือ X-API-Key + anthropic-version

Security
+

เปิดใช้ tools และเอาต์พุตแบบมีโครงสร้าง

รองรับ OpenAI tools/functions, JSON schema และ web_search ในตัว

ความสามารถ
+

ติดตามการใช้งาน

ดูการใช้โทเคนและการค้นหาในหน้านี้หลังเข้าสู่ระบบ

Analytics

ความสามารถ

OpenAI + Anthropic

ทดแทน OpenAI และ Anthropic API ได้ทันที พร้อมรองรับ tools, เอาต์พุตแบบมีโครงสร้าง และเว็บเสิร์ชในตัว

ตัวแทนแบบดรอป‑อิน

เข้ากันได้

ทำงานร่วมกับ SDK ของ OpenAI และ Anthropic เพียงเปลี่ยน base URL

การเรียกฟังก์ชัน

เครื่องมือ

กำหนดเครื่องมือให้ Shannon เรียกใช้ รองรับโหมด auto, forced และ none

ค้นหาเว็บในตัว

ค้นหา

ค้นหาเว็บแบบเรียลไทม์พร้อมการอ้างอิงแหล่งที่มา ใช้งานได้อัตโนมัติ

ผลลัพธ์แบบมีโครงสร้าง

JSON

โหมด JSON และบังคับใช้ JSON Schema เพื่อดึงข้อมูลได้อย่างเชื่อถือ

เครื่องมือหลายรอบ

เอเจนต์

ลูปการเรียกใช้ฟังก์ชันอัตโนมัติ สูงสุด 10 รอบต่อคำขอ

สตรีมมิง

เร็ว

Server‑sent events สำหรับสตรีมโทเคนแบบเรียลไทม์

เริ่มต้นอย่างรวดเร็ว

5 นาที

เริ่มได้ในสามขั้นตอน Shannon จำลองไคลเอนต์ OpenAI และ Anthropic

ตั้งค่า base URL

ใช้ endpoint ที่เข้ากันได้กับ OpenAI

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

เพิ่ม API key

ใช้ Bearer auth ใน Authorization header

ส่งข้อความแรก

เลือกภาษาแล้วใส่คีย์ของคุณ

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

รูปแบบการตอบกลับ

ตอบกลับสำเร็จ

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

ใหม่

ทดสอบ Shannon API ได้โดยตรงในเบราว์เซอร์ สร้างคำขอ รัน แล้วดูผลแบบเรียลไทม์

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.

/th/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 V2 รับคีย์ API

การยืนยันตัวตน

ทุกคำขอ API ต้องยืนยันตัวตนด้วย Shannon API key ของคุณ

OpenAI Format (Recommended)

HTTP

Authorization: Bearer YOUR_API_KEY

รูปแบบ Anthropic

HTTP

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

โมเดล

Shannon มีหลายโมเดลที่ปรับแต่งให้เหมาะกับแต่ละงาน

shannon-1.6-lite Shannon 1.6 Lite

Fast, efficient responses for everyday tasks

บริบท 128K

เหมาะที่สุดสำหรับ Chat, Q&A, Content Generation

shannon-1.6-pro Shannon 1.6 Pro

Advanced reasoning for complex problems

บริบท 128K

เหมาะที่สุดสำหรับ Analysis, Research, Complex Tasks

shannon-2-lite Shannon 2 Lite

บริบท 128K

เหมาะที่สุดสำหรับ

shannon-2-pro Shannon 2 Pro

บริบท 128K

เหมาะที่สุดสำหรับ

shannon-coder-1 Shannon Coder

Optimized for Claude Code CLI with call-based quota

บริบท 128K

เหมาะที่สุดสำหรับ Code Generation, Tool Use, CLI Integration

Call-based quota

การเรียกฟังก์ชัน

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

ตัวเลือกการเลือกเครื่องมือ

"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

การตอบกลับการเรียกใช้ฟังก์ชัน

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

เอาต์พุตแบบมีโครงสร้าง

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

ตัวเลือกรูปแบบการตอบกลับ

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

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

สตรีมมิง

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

เคล็ดลับ: Streaming responses arrive as Server-Sent Events. Each chunk contains a delta with partial content.

ค้นหาเว็บในตัว

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

เคล็ดลับโปร: ผลลัพธ์เว็บเสิร์ชมีแหล่งอ้างอิง Shannon จะอ้างอิงแหล่งข้อมูลให้อัตโนมัติ

รูปแบบ Anthropic

Shannon รองรับรูปแบบ 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);

ส่วนหัวที่จำเป็น: Anthropic format requires anthropic-version: 2023-06-01.

SDKs

เข้ากันได้

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

การจัดการข้อผิดพลาด

Shannon ใช้รหัสสถานะ HTTP มาตรฐานและส่งข้อความข้อผิดพลาดแบบละเอียด

400 คำขอไม่ถูกต้อง รูปแบบคำขอหรือพารามิเตอร์ไม่ถูกต้อง

401 ไม่ได้รับอนุญาต API key ไม่ถูกต้องหรือหายไป

402 เกินโควตา เกินโควตาโทเคนหรือการค้นหา

429 ถูกจำกัดอัตรา คำขอมากเกินไป โปรดช้าลง

500 ข้อผิดพลาดของเซิร์ฟเวอร์ ข้อผิดพลาดภายใน โปรดลองอีกครั้งภายหลัง

รูปแบบการตอบกลับข้อผิดพลาด

การตอบกลับข้อผิดพลาด

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

บันทึกการเปลี่ยนแปลง

LOG

Recent updates and improvements to the Shannon API.

v2.1.0

2025-01-03

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

v2.0.0

2024-12-15

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

v1.5.0

2024-11-20

ใหม่ Added shannon-deep-dapo model for complex reasoning
ใหม่ Built-in web_search function
Improved Reduced latency for streaming responses

v1.0.0

2024-10-01

ใหม่ Initial API release
ใหม่ OpenAI-compatible chat completions endpoint
ใหม่ Function calling support
ใหม่ Streaming via Server-Sent Events

API key ของคุณ

Access

ใช้ Bearer สำหรับ OpenAI หรือ X-API-Key + anthropic-version

YOUR_API_KEY

รับคีย์ API

เก็บ API key เป็นความลับ การสร้างใหม่จะสร้างคีย์ใหม่และยกเลิกคีย์เดิม

การใช้งานของคุณ

ดูการใช้โทเคนและการค้นหาในหน้านี้หลังเข้าสู่ระบบ

-- การเรียก API

-- โทเคนที่ใช้

Shannon API

ภาพรวม

ความสามารถ

ตัวแทนแบบดรอป‑อิน

การเรียกฟังก์ชัน

ค้นหาเว็บในตัว

ผลลัพธ์แบบมีโครงสร้าง

เครื่องมือหลายรอบ

สตรีมมิง

เริ่มต้นอย่างรวดเร็ว

ตั้งค่า base URL

เพิ่ม API key

ส่งข้อความแรก

รูปแบบการตอบกลับ

สนามทดลอง API

Chat, Responses, Messages

Stream live output

Reuse your key

การยืนยันตัวตน

OpenAI Format (Recommended)

รูปแบบ Anthropic

โมเดล

การเรียกฟังก์ชัน

ตัวเลือกการเลือกเครื่องมือ

การตอบกลับการเรียกใช้ฟังก์ชัน

เอาต์พุตแบบมีโครงสร้าง

ตัวเลือกรูปแบบการตอบกลับ

สตรีมมิง

ค้นหาเว็บในตัว

รูปแบบ Anthropic

SDKs

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

การจัดการข้อผิดพลาด

รูปแบบการตอบกลับข้อผิดพลาด

บันทึกการเปลี่ยนแปลง

API key ของคุณ

การใช้งานของคุณ

Shannon Coder (shannon-coder-1)

พร้อมสร้างแล้วหรือยัง?

Shannon AI API Documentation

ภาพรวม

ความสามารถ

ตัวแทนแบบดรอป‑อิน

การเรียกฟังก์ชัน

ค้นหาเว็บในตัว

ผลลัพธ์แบบมีโครงสร้าง

เครื่องมือหลายรอบ

สตรีมมิง

เริ่มต้นอย่างรวดเร็ว

ตั้งค่า base URL

เพิ่ม API key

ส่งข้อความแรก

รูปแบบการตอบกลับ

สนามทดลอง API

Chat, Responses, Messages

Stream live output

Reuse your key

การยืนยันตัวตน

OpenAI Format (Recommended)

รูปแบบ Anthropic

โมเดล

การเรียกฟังก์ชัน

ตัวเลือกการเลือกเครื่องมือ

การตอบกลับการเรียกใช้ฟังก์ชัน

เอาต์พุตแบบมีโครงสร้าง

ตัวเลือกรูปแบบการตอบกลับ

สตรีมมิง

ค้นหาเว็บในตัว

รูปแบบ Anthropic

SDKs

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

การจัดการข้อผิดพลาด

รูปแบบการตอบกลับข้อผิดพลาด

บันทึกการเปลี่ยนแปลง

API key ของคุณ

การใช้งานของคุณ

Shannon Coder (shannon-coder-1)

พร้อมสร้างแล้วหรือยัง?