เอกสาร

Smart AIPI รองรับทั้ง APIs ที่เข้ากันได้กับ OpenAI และ Anthropic ใช้บริการของเราได้กับ OpenAI หรือ Anthropic SDK, tool หรือแอปที่มีอยู่เดิม เพียงแค่เปลี่ยน base URL โดยไม่ต้องแก้โค้ดเลย

CLI และ MCP Tools

Smart AIPI มี npm packages สองตัวเพื่อช่วยให้นักพัฒนาจัดการบัญชีของตนได้สะดวกขึ้น:

ติดตั้งทั้งสองอย่าง

ติดตั้งแยกกัน

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

ทุก API request ต้องใช้ API key โดย key เดียวกันใช้ได้กับทั้งสองวิธีการยืนยันตัวตน:

คู่มือการย้ายระบบ

การย้ายใช้งานใช้เวลาไม่ถึงหนึ่งนาที API ของเรารองรับทั้ง OpenAI และ Anthropic endpoints แบบเข้ากันได้ 100%

จาก OpenAI

จาก Anthropic

เสร็จสิ้นการแชท

สร้าง chat completion จาก messages และ model ที่ระบุ นี่คือ endpoint หลักสำหรับการใช้งาน language models

พารามิเตอร์ใน Request Body

บทบาทของข้อความ

ตัวอย่างโค้ด

from openai import OpenAI

client = OpenAI(
    base_url="https://api.smartaipi.com/v1",
    api_key="your-api-key"
)

response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)

import OpenAI from 'openai';

const openai = new OpenAI({
    baseURL: 'https://api.smartaipi.com/v1',
    apiKey: 'your-api-key'
});

const response = await openai.chat.completions.create({
    model: 'gpt-6-astra',
    messages: [
        { role: 'system', content: 'You are a helpful assistant.' },
        { role: 'user', content: 'Hello!' }
    ],
    temperature: 0.7,
    max_tokens: 1000
});

console.log(response.choices[0].message.content);

curl https://api.smartaipi.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello!"}
    ],
    "temperature": 0.7,
    "max_tokens": 1000
  }'

package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("your-api-key")
    config.BaseURL = "https://api.smartaipi.com/v1"
    client := openai.NewClientWithConfig(config)

    resp, _ := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "gpt-6-astra",
            Messages: []openai.ChatCompletionMessage{
                {Role: "system", Content: "You are a helpful assistant."},
                {Role: "user", Content: "Hello!"},
            },
            Temperature: 0.7,
            MaxTokens:   1000,
        },
    )
    fmt.Println(resp.Choices[0].Message.Content)
}

use async_openai::{Client, config::OpenAIConfig};
use async_openai::types::{
    CreateChatCompletionRequestArgs, ChatCompletionRequestMessage,
    ChatCompletionRequestSystemMessageArgs, ChatCompletionRequestUserMessageArgs,
};

let config = OpenAIConfig::new()
    .with_api_key("your-api-key")
    .with_api_base("https://api.smartaipi.com/v1");

let client = Client::with_config(config);

let request = CreateChatCompletionRequestArgs::default()
    .model("gpt-6-astra")
    .messages([
        ChatCompletionRequestSystemMessageArgs::default()
            .content("You are a helpful assistant.")
            .build()?.into(),
        ChatCompletionRequestUserMessageArgs::default()
            .content("Hello!")
            .build()?.into(),
    ])
    .build()?;

let response = client.chat().create(request).await?;
println!("{}", response.choices[0].message.content);

Streaming

เปิดใช้งาน streaming เพื่อรับ tokens ทันทีที่ถูกสร้างผ่าน Server-Sent Events (SSE) ซึ่งช่วยให้ประสบการณ์ผู้ใช้ดีขึ้นสำหรับ responses ที่ยาว

ตัวอย่าง Streaming

from openai import OpenAI

client = OpenAI(
    base_url="https://api.smartaipi.com/v1",
    api_key="your-api-key"
)

# Enable streaming
stream = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

# Process chunks as they arrive
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

const stream = await openai.chat.completions.create({
    model: 'gpt-6-astra',
    messages: [{ role: 'user', content: 'Write a poem' }],
    stream: true,
});

for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content || '';
    process.stdout.write(content);
}

ความพยายามในการใช้เหตุผล

ควบคุมความลึกของ reasoning ด้วยพารามิเตอร์ reasoning_effort สำหรับโมเดล GPT-5

โมเดลที่รองรับ

ระดับ Reasoning Effort

โหมดเร็ว (Priority Processing)

ใช้ service_tier: "priority" สำหรับ priority processing ที่มี latency ต่ำลง นี่คือสิ่งที่คำสั่ง /fast ใน Codex CLI ใช้งาน มันไม่ได้เปลี่ยนความลึกของ reasoning — คุณจะได้คุณภาพเท่าเดิม แต่เร็วขึ้น

response = client.responses.create(
    model="gpt-6-astra",
    input="Refactor this function",
    service_tier="priority"              # priority processing, lower latency
)

เสร็จสิ้นการแชท API

response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Analyze this code for bugs..."}],
    reasoning_effort="high"  # or "xhigh" for maximum depth
)

คำตอบ API

# Reasoning is set via the "reasoning" object
response = client.responses.create(
    model="gpt-6-astra",
    input=[{"role": "user", "content": "Refactor this function..."}],
    reasoning={"effort": "high"}  # defaults to "high" on Smart AIPI
)

การสร้างรูปภาพ

สร้างรูปภาพจาก text prompts ด้วย image generation endpoint ของเรา

พารามิเตอร์ใน Request Body

โมเดลที่พร้อมใช้งาน

ตัวอย่าง

response = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="A futuristic city at sunset, cyberpunk style",
    size="1024x1024",
    n=1
)

# Response contains base64-encoded image
image_b64 = response.data[0].b64_json

# Save to file
import base64
with open("output.png", "wb") as f:
    f.write(base64.b64decode(image_b64))

curl https://api.smartaipi.com/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-image-2.5-flare",
    "prompt": "A futuristic city at sunset",
    "n": 1,
    "size": "1024x1024"
  }'

การแก้ไขรูปภาพ

แก้ไขรูปภาพที่มีอยู่ด้วย text prompt รองรับทั้ง JSON (สตริง base64) และ multipart/form-data (อัปโหลดไฟล์) ดังนั้น OpenAI SDKs จึงใช้งานได้ทันที

พารามิเตอร์ใน Request Body

ตัวอย่าง

import base64

response = client.images.edit(
    model="gpt-image-2.5-flare",
    image=open("input.png", "rb"),
    prompt="Change the background to a sunset beach",
    size="1024x1024",
    n=1
)

# Save the edited image
edited_b64 = response.data[0].b64_json
with open("edited.png", "wb") as f:
    f.write(base64.b64decode(edited_b64))

curl https://api.smartaipi.com/v1/images/edits \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "model=gpt-image-2.5-flare" \
  -F "prompt=Change the background to a sunset beach" \
  -F "[email protected]" \
  -F "size=1024x1024" \
  -F "n=1"

Realtime API ด้วย WebSocket

WebSockets WebSockets เป็น API ที่รองรับอย่างกว้างขวางสำหรับการส่งข้อมูลแบบ realtime และเป็นตัวเลือกที่ยอดเยี่ยมสำหรับการเชื่อมต่อกับ Smart AIPI Realtime API ในแอปพลิเคชันแบบ server-to-server

ในการเชื่อมต่อแบบ server-to-server ระบบ backend ของคุณจะเชื่อมต่อผ่าน WebSocket ไปยัง Realtime API โดยตรง ใช้ API มาตรฐานเพื่อยืนยันตัวตนการเชื่อมต่อ เพราะ token นี้มีอยู่ได้เฉพาะบน backend server ที่ปลอดภัยของคุณเท่านั้น

เชื่อมต่อผ่าน WebSocket

ด้านล่างนี้เป็นตัวอย่างหลายแบบของการเชื่อมต่อผ่าน WebSocket นอกจากการใช้ WebSocket URL แล้ว คุณยังต้องส่ง authentication header โดยใช้ API key ของคุณด้วย

import WebSocket from "ws";

const url = "wss://api.smartaipi.com/v1/responses";
const ws = new WebSocket(url, {
  headers: {
    Authorization: "Bearer " + process.env.SMARTAIPI_API_KEY,
  },
});

ws.on("open", function open() {
  console.log("Connected to server.");

  // Send a response.create event
  ws.send(JSON.stringify({
    type: "response.create",
    response: {

      model: "gpt-6-astra",
      store: false,
      input: [{ role: "user", content: "Hello!" }],
      stream: true,
    },
  }));
});

ws.on("message", function incoming(message) {
  const event = JSON.parse(message.toString());
  console.log(event.type, event);
});

import os, json, websocket

url = "wss://api.smartaipi.com/v1/responses"
headers = ["Authorization: Bearer " + os.environ["SMARTAIPI_API_KEY"]]

def on_open(ws):
    print("Connected to server.")
    ws.send(json.dumps({
        "type": "response.create",
        "response": {
            "model": "gpt-6-astra",
            "store": False,
            "input": [{"role": "user", "content": "Hello!"}],
            "stream": True,
        }
    }))

def on_message(ws, message):
    data = json.loads(message)
    print("Event:", data["type"])

ws = websocket.WebSocketApp(url, header=headers,
    on_open=on_open, on_message=on_message)
ws.run_forever()

# Verify WebSocket handshake (requires curl with --http1.1)
curl --max-time 5 --http1.1 -i -N \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Connection: Upgrade" \
  -H "Upgrade: websocket" \
  -H "Sec-WebSocket-Version: 13" \
  -H "Sec-WebSocket-Key: $(openssl rand -base64 16)" \
  "https://api.smartaipi.com/v1/responses"

# A successful handshake returns:
# HTTP/1.1 101 Switching Protocols
# upgrade: websocket
# sec-websocket-accept: ...

การส่งและรับ Events

sessions ถูกจัดการด้วย JSON events ที่ส่งจาก client และ server ผ่านการเชื่อมต่อ WebSocket ให้ครอบ request ของคุณไว้ใน response.create ซองจดหมาย:

รายการโมเดล

ดึงรายการโมเดลทั้งหมดที่พร้อมใช้งาน ใช้ endpoint นี้เพื่อค้นหาแบบ dynamic ว่ามีโมเดลใดบ้างสำหรับบัญชีของคุณ

รูปแบบ Response

{
    "object": "list",
    "data": [
        {
            "id": "gpt-6-astra",
            "object": "model",
            "created": 1700000000,
            "owned_by": "smart-aipi"
        },
        {
            "id": "gpt-5.3-codex",
            "object": "model",
            "created": 1700000000,
            "owned_by": "smart-aipi"
        },
        // ... more models
    ]
}

ตัวอย่าง

from openai import OpenAI

client = OpenAI(
    base_url="https://api.smartaipi.com/v1",
    api_key="your-api-key"
)

# List all available models
models = client.models.list()

for model in models.data:
    print(model.id)

curl https://api.smartaipi.com/v1/models \
  -H "Authorization: Bearer YOUR_API_KEY"

โมเดลที่พร้อมใช้งาน

Anthropic ข้อความ API

รองรับ Anthropic Messages API เต็มรูปแบบ ใช้ได้กับ Anthropic SDK, Claude Code หรือแอปใด ๆ ที่รองรับ Anthropic protocol ได้ทันที แค่เปลี่ยน base URL

ฟีเจอร์ที่รองรับ

ตัวอย่างโค้ด

from anthropic import Anthropic

client = Anthropic(
    base_url="https://api.smartaipi.com",
    api_key="your-api-key"
)

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello!"}
    ]
)

print(response.content[0].text)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
    baseURL: 'https://api.smartaipi.com',
    apiKey: 'your-api-key'
});

const response = await client.messages.create({
    model: 'claude-sonnet-4-5-20250929',
    max_tokens: 1024,
    messages: [
        { role: 'user', content: 'Hello!' }
    ]
});

console.log(response.content[0].text);

curl https://api.smartaipi.com/v1/messages \
  -H "x-api-key: your-api-key" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-20250929",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Hello!"}
    ]
  }'

การแมปโมเดล

ชื่อโมเดล Claude สามารถใช้ได้และจะถูก route อัตโนมัติไปยัง GPT-5.4 พร้อม reasoning effort แบบแบ่งระดับ ทุก response จะมี x-actual-model header ที่แสดง backend model จริง

Claude Code

ใช้ Claude Code กับ Smart AIPI เป็น backend รองรับการใช้ tools, streaming และความสามารถแบบ agentic เต็มรูปแบบ

ตั้งค่าอัตโนมัติ

npx smart-aipi claude

วิธีนี้จะตั้งค่า ~/.claude/settings.json และ ~/.claude.json ให้อัตโนมัติ ถ้าคุณตั้งค่า Claude Code กับบัญชี Anthropic ไว้อยู่แล้ว ระบบจะแสดงการตั้งค่าด้วยตนเองแทนการเขียนทับ

ตั้งค่าด้วยตนเอง

เพิ่มลงใน ~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.smartaipi.com",
    "ANTHROPIC_API_KEY": "sk-your-key",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4-5-20251001"
  },
  "model": "opus"
}

จากนั้นเพิ่ม "hasCompletedOnboarding": true ไปที่ ~/.claude.json เพื่อข้าม setup wizard

แต่ละการตั้งค่าทำอะไรบ้าง

OpenCode

ใช้ Smart AIPI เป็น OpenCode backend ของคุณผ่าน OpenAI-compatible SDK

ตั้งค่า Config

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "smart-aipi": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Smart AIPI",
      "options": {
        "baseURL": "https://api.smartaipi.com/v1",
        "apiKey": "YOUR_API_KEY"
      },
      "models": {
        "gpt-6-astra": {
          "name": "GPT-6 Astra",
          "reasoning": true,
          "limit": { "context": 400000, "output": 128000 }
        },
        "gpt-5.3-codex": {
          "name": "GPT-5.3 Codex",
          "reasoning": true,
          "limit": { "context": 400000, "output": 128000 }
        },
        "gpt-5.2-codex": {
          "name": "GPT-5.2 Codex",
          "reasoning": true,
          "limit": { "context": 400000, "output": 128000 }
        },
        "gpt-5-codex": {
          "name": "GPT-5 Codex",
          "reasoning": true,
          "limit": { "context": 400000, "output": 128000 }
        }
      }
    }
  },
  "model": "smart-aipi/gpt-6-astra"
}

โคเด็กซ์ CLI

ใช้ Smart AIPI กับเครื่องมือ Codex CLI ของ OpenAI ต้องตั้งค่า 3 ไฟล์

ตั้งค่าอัตโนมัติ

npx smart-aipi codex

วิธีนี้จะตั้งค่าทั้งสามไฟล์ด้านล่างให้อัตโนมัติ หลังจากรันแล้ว ให้เพิ่ม model_reasoning_effort ลงใน config ของคุณ (ดูขั้นตอนที่ 2)

ตั้งค่าด้วยตนเอง

ตั้งค่าทั้งสามไฟล์นี้:

1. API คีย์ — ~/.codex/auth.json

{
  "auth_mode": "apikey",
  "OPENAI_API_KEY": "sk-your-key"
}

2. Model และ Reasoning — ~/.codex/config.toml

model = "gpt-6-astra"
model_reasoning_effort = "high"

ระดับ reasoning ที่ใช้ได้: low, medium, high (แนะนำ), xhigh.

3. ตัวแปรสภาพแวดล้อม — ~/.zshrc

# Smart AIPI
export OPENAI_API_KEY="sk-your-key"
export OPENAI_BASE_URL="https://api.smartaipi.com/v1"

จากนั้นใช้ Codex ตามปกติ:

codex "fix this bug"

คู่มือความเร็ว Codex WebSocket

โหมด WebSocket มักจะเร็วกว่าในการทำ agentic coding flows ที่มีการเรียก tools จำนวนมาก แทนที่จะเชื่อมต่อใหม่ซ้ำ ๆ ผ่าน HTTP และส่ง request envelopes แบบเต็มทุกครั้ง Codex จะคงการเชื่อมต่อเดียวไว้และส่ง turns แบบ incremental ซึ่งช่วยลด continuation overhead

เปิดใช้งาน WebSockets ใน Codex

ใช้ WebSocket v2 feature flag ใน ~/.codex/config.toml: ~/.codex/config.toml:

model = "gpt-6-astra"
model_reasoning_effort = "high"

[features]
responses_websockets_v2 = true

CLI ที่เทียบเท่า:

codex --enable responses_websockets_v2

build รุ่นเก่าอาจใช้ flag แบบ legacy:

[features]
responses_websockets = true

พฤติกรรมที่พบใน Homebrew

ในบาง build ที่แจกจ่ายผ่าน Homebrew, WebSocket turns อาจค้างระหว่างงานที่ใช้เวลานาน แล้ว fallback กลับไปใช้ HTTP แบบเงียบ ๆ เราพบสิ่งนี้โดยเฉพาะในลูป tool-call ที่ซับซ้อน การ build ใหม่จากโค้ดโอเพนซอร์สพร้อมการแก้ไขด้านล่างช่วยเพิ่มทั้งเสถียรภาพและความเร็ว

หลัง Merge: แก้บั๊ก Open-Source WebSocket

หลัง merge branch ของคุณแล้ว ให้ใช้ checklist นี้เพื่อยืนยันว่า fix อยู่ใน local binary ของคุณแล้ว:

# 1) Pull merged main
git checkout main
git pull --ff-only

# 2) Confirm websocket flags exist
codex features list | rg responses_websockets

# 3) Build and install
cd codex-rs
cargo build --release
install -m 0755 target/release/codex ~/.local/bin/codex-beta

# 4) Run with websocket enabled
CODEX_RS_RESPONSES_WS=true \
OPENAI_BASE_URL=https://api.smartaipi.com/v1 \
~/.local/bin/codex-beta --enable responses_websockets_v2

ถ้าคุณต้อง patch ด้วยตัวเอง ให้ตรวจสอบว่ามีการแก้ไขระดับโค้ดเหล่านี้อยู่:

# A) Build websocket request with IntoClientRequest so required headers are set
let mut request = url.as_str().into_client_request()?;
request.headers_mut().extend(headers);

# B) Ensure TLS roots are enabled for tokio-tungstenite in Cargo.toml
tokio-tungstenite = { version = "...", features = ["rustls-tls-native-roots"] }

Cursor และ Cline

ใช้ Smart AIPI กับ Cursor IDE หรือส่วนขยาย Cline บน VS Code

แชต

ใช้ Smart AIPI Chat ที่ chat.smartaipi.com. สำหรับ workflow ด้านข้อความ รูปภาพ วิดีโอ โค้ด การค้นหา และเสียง

ฟีเจอร์

• ✓ แชต — การสนทนาข้อความทั่วไปด้วยโมเดลของ Smart AIPI
• ✓ รูปภาพ — สร้างและแก้ไขรูปภาพจาก prompts
• ✓ วิดีโอ — สร้างวิดีโอจากข้อความหรือ image inputs
• ✓ โค้ด — ช่วยเขียนและแก้ไขโค้ดในเบราว์เซอร์
• ✓ ค้นหา — ใช้การค้นหาเว็บเพื่อคำตอบที่มีแหล่งอ้างอิง
• ✓ เสียง — พูดคุยกับโมเดลด้วยเสียงทั้ง input และ responses

เริ่มต้นใช้งาน

การคิดค่าบริการ: การใช้งานจะถูกคิดค่าบริการจากเครดิต Smart AIPI ของคุณ

ตัวทดสอบ API

ทดสอบ API ได้โดยตรงจากเบราว์เซอร์ของคุณ: