Shannon AI API 문서

개요

공개 문서

Shannon의 OpenAI/Anthropic 호환 API로 출시하는 데 필요한 모든 것.

기본 URL OpenAI 호환

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

function calling 및 streaming을 지원하는 Chat Completions API를 사용하세요.

기본 URL Anthropic 호환

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

tools와 anthropic-version 헤더를 사용하는 Claude Messages 형식입니다.

헤더 인증

인증: Bearer <your-key>

또는 Claude 형식 호출에는 X-API-Key + anthropic-version을 사용하세요.

Access Status

Public docs - Key required to call

Streaming, function calling, 구조화 출력, 웹 검색.

출시 체크리스트

+

SDK를 Shannon으로 연결

baseURL을 위의 OpenAI 또는 Anthropic endpoint로 설정하세요.

Setup
+

API 키 추가

OpenAI에는 Bearer, 또는 X-API-Key + anthropic-version을 사용하세요.

Security
+

tools와 구조화 출력을 활성화

OpenAI tools/functions, JSON schema, 내장 web_search를 지원합니다.

기능
+

사용량 추적

로그인 후 이 페이지에서 토큰 및 검색 사용량을 확인하세요.

Analytics

기능

OpenAI + Anthropic

OpenAI 및 Anthropic API를 위한 드롭인 대체. tools, 구조화 출력, 내장 웹 검색을 네이티브 지원합니다.

드롭인 대체

호환

OpenAI 및 Anthropic SDK와 호환됩니다. 기본 URL만 변경하세요.

함수 호출

도구

도구를 정의하고 Shannon이 호출하도록 합니다. auto, forced, none 모드를 지원합니다.

내장 웹 검색

검색

출처 인용이 포함된 실시간 웹 검색. 자동으로 제공됩니다.

구조화된 출력

JSON

JSON 모드와 JSON Schema 강제로 신뢰할 수 있는 데이터 추출.

멀티턴 도구

에이전틱

함수 실행 자동 루프. 요청당 최대 10회 반복.

스트리밍

빠름

Server‑Sent Events로 실시간 토큰 스트리밍.

빠른 시작

5분

세 단계로 시작하세요. Shannon은 OpenAI와 Anthropic 클라이언트를 반영합니다.

기본 URL 설정

OpenAI 호환 엔드포인트를 사용하세요.

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

API 키 추가

Authorization 헤더에 Bearer 인증을 사용하세요.

첫 메시지 보내기

언어를 선택하고 키로 교체하세요.

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.

/ko/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 키 인증이 필요합니다.

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 키가 없거나 유효하지 않습니다

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 키

Access

OpenAI에는 Bearer, 또는 X-API-Key + anthropic-version을 사용하세요.

YOUR_API_KEY

API 키 받기

API 키를 비밀로 유지하세요. 재생성하면 새 키가 생성되고 기존 키는 무효화됩니다.

사용량

로그인 후 이 페이지에서 토큰 및 검색 사용량을 확인하세요.

-- API 호출

-- 사용 토큰

Shannon API

개요

기능

드롭인 대체

함수 호출

내장 웹 검색

구조화된 출력

멀티턴 도구

스트리밍

빠른 시작

기본 URL 설정

API 키 추가

첫 메시지 보내기

응답 형식

API 플레이그라운드

Chat, Responses, Messages

Stream live output

Reuse your key

인증

OpenAI Format (Recommended)

Anthropic 형식

모델

함수 호출

도구 선택 옵션

함수 호출 응답

구조화된 출력

응답 형식 옵션

스트리밍

내장 웹 검색

Anthropic 형식

SDKs

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

오류 처리

오류 응답 형식

변경 로그

내 API 키

사용량

Shannon Coder (shannon-coder-1)

빌드할 준비가 되셨나요?

Shannon AI API Documentation

개요

기능

드롭인 대체

함수 호출

내장 웹 검색

구조화된 출력

멀티턴 도구

스트리밍

빠른 시작

기본 URL 설정

API 키 추가

첫 메시지 보내기

응답 형식

API 플레이그라운드

Chat, Responses, Messages

Stream live output

Reuse your key

인증

OpenAI Format (Recommended)

Anthropic 형식

모델

함수 호출

도구 선택 옵션

함수 호출 응답

구조화된 출력

응답 형식 옵션

스트리밍

내장 웹 검색

Anthropic 형식

SDKs

OpenAI-Compatible SDKs

Anthropic-Compatible SDKs

오류 처리

오류 응답 형식

변경 로그

내 API 키

사용량

Shannon Coder (shannon-coder-1)

빌드할 준비가 되셨나요?