Shannon AI API დოკუმენტაცია

მიმოხილვა

საჯარო დოკუმენტაცია

ყველაფერი, რაც საჭიროა Shannon-ის OpenAI და Anthropic თავსებად API-თან დასაწყებად.

URL OpenAI-თან თავსებადი

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

გამოიყენეთ Chat Completions API ფუნქციის გამოძახებით და სტრიმინგით.

URL Anthropic-თან თავსებადი

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

Claude Messages ფორმატი ინსტრუმენტებით და anthropic-version ჰედერით.

ჰედერები ავთენტიკაცია

Authorization: Bearer <api-key>

ან X-API-Key და anthropic-version Claude-სტილის გამოძახებებისთვის.

წვდომა სტატუსი

 საჯარო დოკუმენტაცია - გამოძახებისთვის საჭიროა გასაღები

სტრიმინგი, ფუნქციის გამოძახება, სტრუქტურირებული შედეგები, ვებძიება.

გაშვების ჩექლისტი

+

SDK მიმართეთ Shannon-ზე

baseURL მიუთითეთ ზემოთ მოცემულ OpenAI ან Anthropic ენდპოინტებზე.

მორგება
+

დაამაგრეთ API გასაღები

OpenAI გამოძახებებისთვის გამოიყენეთ Bearer ტოკენები ან X-API-Key + anthropic-version.

უსაფრთხოება
+

ჩართეთ ინსტრუმენტები და სტრუქტურირებული შედეგები

მხარს უჭერს OpenAI tools/functions, JSON schema და ჩაშენებულ web_search-ს.

შესაძლებლობები
+

გამოყენების კონტროლი

როდესაც შესული ხართ, ამ გვერდზე ნახავთ ტოკენებისა და ძიების ხარჯს.

ანალიტიკა

შესაძლებლობები

OpenAI + Anthropic

Drop-in ჩანაცვლება OpenAI და Anthropic API-ებისთვის ინსტრუმენტების, სტრუქტურირებული შედეგებისა და ჩაშენებული ვებძიების მხარდაჭერით.

Drop-in ჩანაცვლება

თავსებადი

მუშაობს OpenAI და Anthropic SDK-ებთან. უბრალოდ შეცვალეთ base URL.

ფუნქციის გამოძახება

ინსტრუმენტები

განსაზღვრეთ ინსტრუმენტები, Shannon-მა თავად გამოიძახოს. მხარს უჭერს auto, forced და none რეჟიმებს.

ჩაშენებული ვებძიება

ძიება

რეალურ დროში ვებძიება წყაროების მითითებით. ავტომატურად ხელმისაწვდომია.

სტრუქტურირებული შედეგები

JSON

JSON რეჟიმი და JSON Schema იძულებით გამოყენება სანდო მონაცემთა ამოსაღებად.

მრავალჯერადი ინსტრუმენტები

აგენტური

ფუნქციების ავტომატური შესრულების ციკლები. თითო მოთხოვნაზე 10-მდე იტერაცია.

სტრიმინგი

სწრაფი

Server-sent events რეალურ დროში ტოკენების სტრიმინგისთვის.

სწრაფი დაწყება

5 წუთი

დაიწყეთ სამ ნაბიჯში. Shannon ასახავს OpenAI და Anthropic კლიენტებს.

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

ახალი

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.

/ka/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 ფორმატი (რეკომენდებულია)

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

სწრაფი და ეფექტური პასუხები ყოველდღიური ამოცანებისთვის

კონტექსტი 128K

საუკეთესო ჩატი, კითხვა/პასუხი, კონტენტის გენერაცია

shannon-1.6-pro Shannon 1.6 Pro

რთული პრობლემებისთვის გაუმჯობესებული მსჯელობა

კონტექსტი 128K

საუკეთესო ანალიზი, კვლევა, რთული ამოცანები

shannon-2-lite Shannon 2 Lite

კონტექსტი 128K

საუკეთესო

shannon-2-pro Shannon 2 Pro

კონტექსტი 128K

საუკეთესო

shannon-coder-1 Shannon Coder

Claude Code CLI-ისთვის ოპტიმიზებული, გამოძახების კვოტით

კონტექსტი 128K

საუკეთესო კოდის გენერაცია, ინსტრუმენტების გამოყენება, CLI ინტეგრაცია

კვოტა გამოძახებაზე

ფუნქციის გამოძახება

განსაზღვრეთ ინსტრუმენტები, რომელთა გამოძახებაც შეუძლია Shannon-ს მოქმედებების შესასრულებლად ან ინფორმაციის მისაღებად.

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" მოდელი გადაწყვეტს, გამოიძახოს თუ არა ფუნქცია (ნაგულისხმევი)

"none" გამორთეთ ფუნქციის გამოძახება ამ მოთხოვნისთვის

{"type": "function", "function": {"name": "..."}} მოითხოვეთ კონკრეტული ფუნქციის გამოძახება

ფუნქციის გამოძახების პასუხი

როცა მოდელი ფუნქციას გამოიძახებს

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

სტრუქტურირებული შედეგები

აიძულეთ Shannon, დააბრუნოს ვალიდური JSON, რომელიც თქვენს სქემას ემთხვევა.

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"} ვალიდური JSON-ის იძულება (სქემის გარეშე)

{"type": "json_schema", "json_schema": {...}} ზუსტად თქვენი სქემის შესაბამისი გამოსავალის იძულება

სტრიმინგი

ჩართეთ რეალურ დროში ტოკენების სტრიმინგი Server-Sent Events-ით სწრაფი UI-ებისთვის.

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

რჩევა: სტრიმინგი პასუხები მოდის Server-Sent Events-ით. ყოველი ნაწილი შეიცავს ნაწილობრივი შინაარსის delta-ს.

ჩაშენებული ვებძიება

Shannon მოიცავს ჩაშენებულ web_search ფუნქციას, რომელიც ავტომატურად ხელმისაწვდომია.

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 ფორმატს სჭირდება anthropic-version: 2023-06-01.

SDK-ები

თავსებადი

გამოიყენეთ ნებისმიერი OpenAI ან Anthropic SDK — უბრალოდ შეცვალეთ base URL.

OpenAI-თან თავსებადი SDK-ები

SDK Python

ოფიციალური OpenAI Python SDK — მუშაობს Shannon-თან

pip install openai

დოკუმენტების ნახვა ->

SDK JavaScript / TypeScript

ოფიციალური OpenAI Node.js SDK — მუშაობს Shannon-თან

npm install openai

დოკუმენტების ნახვა ->

SDK Go

საზოგადოებრივი Go კლიენტი OpenAI-თან თავსებადი API-ებისთვის

go get github.com/sashabaranov/go-openai

დოკუმენტების ნახვა ->

SDK Ruby

საზოგადოებრივი Ruby კლიენტი OpenAI-თან თავსებადი API-ებისთვის

gem install ruby-openai

დოკუმენტების ნახვა ->

SDK PHP

საზოგადოებრივი PHP კლიენტი OpenAI-თან თავსებადი API-ებისთვის

composer require openai-php/client

დოკუმენტების ნახვა ->

SDK Rust

Async Rust კლიენტი OpenAI-თან თავსებადი API-ებისთვის

cargo add async-openai

დოკუმენტების ნახვა ->

Anthropic-თან თავსებადი SDK-ები

SDK Python (Anthropic)

ოფიციალური Anthropic Python SDK — მუშაობს Shannon-თან

pip install anthropic

დოკუმენტების ნახვა ->

SDK TypeScript (Anthropic)

ოფიციალური Anthropic TypeScript SDK — მუშაობს Shannon-თან

npm install @anthropic-ai/sdk

დოკუმენტების ნახვა ->

შეცდომების დამუშავება

Shannon იყენებს სტანდარტულ HTTP სტატუს კოდებს და აბრუნებს დეტალურ შეცდომის შეტყობინებებს.

400 არასწორი მოთხოვნა მოთხოვნის ფორმატი ან პარამეტრები არასწორია

401 ავტორიზაცია ვერ მოხერხდა არასწორი ან გამოტოვებული API გასაღები

402 კვოტა გადაჭარბდა ტოკენების ან ძიების კვოტა გადაჭარბდა

429 სიხშირის შეზღუდვა ძალიან ბევრი მოთხოვნა, შეანელეთ

500 სერვერის შეცდომა შიდა შეცდომა, სცადეთ მოგვიანებით

შეცდომის პასუხის ფორმატი

შეცდომის პასუხი

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

ცვლილებების ჟურნალი

LOG

Shannon API-ის უახლესი განახლებები და გაუმჯობესებები.

v2.1.0

2025-01-03

ახალი დაემატა shannon-coder-1 მოდელი Claude Code CLI ინტეგრაციისთვის
ახალი Coder მოდელისთვის გამოძახებაზე დაფუძნებული კვოტის სისტემა
გაუმჯობესებული ფუნქციის გამოძახების სანდოობა გაუმჯობესდა

v2.0.0

2024-12-15

ახალი დაემატა Anthropic Messages API თავსებადობა
ახალი მრავალსაფეხურიანი ინსტრუმენტების შესრულება (10-მდე იტერაცია)
ახალი JSON Schema პასუხის ფორმატის მხარდაჭერა
გაუმჯობესებული გაუმჯობესებული ვებძიება უკეთესი ციტატებით

v1.5.0

2024-11-20

ახალი დაემატა shannon-deep-dapo მოდელი რთული მსჯელობისთვის
ახალი ჩაშენებული web_search ფუნქცია
გაუმჯობესებული სტრიმინგ პასუხებისთვის დაიკლო დაყოვნებამ

v1.0.0

2024-10-01

ახალი API-ის საწყისი გამოშვება
ახალი OpenAI-თან თავსებადი chat completions ენდპოინტი
ახალი ფუნქციის გამოძახების მხარდაჭერა
ახალი სტრიმინგი Server-Sent Events-ით

თქვენი API გასაღები

წვდომა

OpenAI გამოძახებებისთვის გამოიყენეთ Bearer ტოკენები ან X-API-Key + anthropic-version.

YOUR_API_KEY

API გასაღების მიღება

შეინახეთ თქვენი API გასაღები საიდუმლოდ. ხელახლა გენერირება ქმნის ახალ გასაღებს და ძველს აუქმებს.

თქვენი გამოყენება

როდესაც შესული ხართ, ამ გვერდზე ნახავთ ტოკენებისა და ძიების ხარჯს.

-- API გამოძახებები

-- გამოყენებული ტოკენები

Shannon API

მიმოხილვა

შესაძლებლობები

Drop-in ჩანაცვლება

ფუნქციის გამოძახება

ჩაშენებული ვებძიება

სტრუქტურირებული შედეგები

მრავალჯერადი ინსტრუმენტები

სტრიმინგი

სწრაფი დაწყება

Base URL-ის დაყენება

API გასაღების დამატება

გააგზავნეთ პირველი შეტყობინება

პასუხის ფორმატი

API Playground

Chat, Responses, Messages

Stream live output

Reuse your key

ავთენტიკაცია

OpenAI ფორმატი (რეკომენდებულია)

Anthropic ფორმატი

მოდელები

ფუნქციის გამოძახება

ინსტრუმენტის არჩევის ვარიანტები

ფუნქციის გამოძახების პასუხი

სტრუქტურირებული შედეგები

პასუხის ფორმატის ვარიანტები

სტრიმინგი

ჩაშენებული ვებძიება

Anthropic ფორმატი

SDK-ები

OpenAI-თან თავსებადი SDK-ები

Anthropic-თან თავსებადი SDK-ები

შეცდომების დამუშავება

შეცდომის პასუხის ფორმატი

ცვლილებების ჟურნალი

თქვენი API გასაღები

თქვენი გამოყენება

Shannon Coder (shannon-coder-1)

მზად ხართ ასაშენებლად?

Shannon AI API Documentation

მიმოხილვა

შესაძლებლობები

Drop-in ჩანაცვლება

ფუნქციის გამოძახება

ჩაშენებული ვებძიება

სტრუქტურირებული შედეგები

მრავალჯერადი ინსტრუმენტები

სტრიმინგი

სწრაფი დაწყება

Base URL-ის დაყენება

API გასაღების დამატება

გააგზავნეთ პირველი შეტყობინება

პასუხის ფორმატი

API Playground

Chat, Responses, Messages

Stream live output

Reuse your key

ავთენტიკაცია

OpenAI ფორმატი (რეკომენდებულია)

Anthropic ფორმატი

მოდელები

ფუნქციის გამოძახება

ინსტრუმენტის არჩევის ვარიანტები

ფუნქციის გამოძახების პასუხი

სტრუქტურირებული შედეგები

პასუხის ფორმატის ვარიანტები

სტრიმინგი

ჩაშენებული ვებძიება

Anthropic ფორმატი

SDK-ები

OpenAI-თან თავსებადი SDK-ები

Anthropic-თან თავსებადი SDK-ები

შეცდომების დამუშავება

შეცდომის პასუხის ფორმატი

ცვლილებების ჟურნალი

თქვენი API გასაღები

თქვენი გამოყენება

Shannon Coder (shannon-coder-1)

მზად ხართ ასაშენებლად?