Dokumentasi

Smart AIPI menyediakan API yang kompatibel dengan OpenAI dan Anthropic. Gunakan layanan kami dengan SDK, tool, atau aplikasi OpenAI maupun Anthropic yang sudah ada hanya dengan mengganti base URL. Tanpa perlu perubahan kode.

Alat CLI & MCP

Smart AIPI menyediakan dua package npm untuk membantu developer bekerja dengan akun mereka:

Install Keduanya

Install Satu per Satu

Autentikasi

Semua request API memerlukan API key. Key yang sama bisa digunakan untuk kedua metode autentikasi:

Panduan Migrasi

Migrasi hanya butuh kurang dari satu menit. API kami 100% kompatibel dengan endpoint OpenAI dan Anthropic.

Dari OpenAI

Dari Anthropic

Chat Completions

Buat chat completion untuk messages dan model yang diberikan. Ini adalah endpoint utama untuk berinteraksi dengan model bahasa.

Parameter Request Body

Role Pesan

Contoh Kode

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

Aktifkan streaming untuk menerima tokens saat dihasilkan melalui Server-Sent Events (SSE). Ini memberikan pengalaman pengguna yang lebih baik untuk respons panjang.

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

Upaya Reasoning

Kontrol kedalaman reasoning dengan parameter reasoning_effort untuk model GPT-5.

Model yang Didukung

Level Reasoning Effort

Mode Cepat (Pemrosesan Prioritas)

Gunakan service_tier: "priority" untuk pemrosesan prioritas dengan latensi lebih rendah. Inilah yang digunakan perintah /fast di Codex CLI. Ini tidak mengubah kedalaman reasoning - kualitasnya sama, hanya lebih cepat.

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

API Chat Completions

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
)

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

Pembuatan Gambar

Buat gambar dari prompt teks menggunakan endpoint pembuatan gambar kami.

Parameter Request Body

Model yang Tersedia

Contoh

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

Edit Gambar

Edit gambar yang sudah ada menggunakan prompt teks. Mendukung JSON (string base64) dan multipart/form-data (upload file), jadi SDK OpenAI langsung bisa dipakai.

Parameter Request Body

Contoh

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

WebSockets adalah API yang didukung luas untuk transfer data realtime, dan pilihan yang tepat untuk terhubung ke Smart AIPI Realtime API dalam aplikasi server-to-server.

Dalam integrasi server-to-server, sistem backend Anda terhubung via WebSocket langsung ke Realtime API. Gunakan API key standar untuk mengautentikasi koneksi, karena token hanya tersedia di server backend aman Anda.

Hubungkan via WebSocket

Di bawah ini ada beberapa contoh koneksi via WebSocket. Selain menggunakan URL WebSocket, Anda juga perlu mengirim header autentikasi menggunakan API key Anda.

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

Mengirim dan Menerima Event

Sesi dikelola menggunakan event JSON yang dikirim client dan server melalui koneksi WebSocket. Bungkus request Anda dalam envelope response.create :

Daftar Model

Ambil daftar semua model yang tersedia. Gunakan endpoint ini untuk mengetahui model mana yang tersedia untuk akun Anda secara dinamis.

Format Respons

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

Contoh

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"

Model yang Tersedia

Anthropic Messages API

Kompatibilitas penuh dengan Anthropic Messages API. Gunakan SDK Anthropic apa pun, Claude Code, atau aplikasi yang memakai protokol Anthropic - cukup ganti base URL.

Fitur yang Didukung

Contoh Kode

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

Pemetaan Model

Nama model Claude diterima dan secara otomatis diarahkan ke GPT-5.4 dengan effort reasoning bertingkat. Setiap respons menyertakan header x-actual-model yang menampilkan model backend asli.

Claude Code

Gunakan Claude Code dengan Smart AIPI sebagai backend. Mendukung penuh penggunaan tool, streaming, dan kapabilitas agentic.

Setup Otomatis

npx smart-aipi claude

Ini akan mengonfigurasi ~/.claude/settings.json dan ~/.claude.json secara otomatis. Jika Anda sudah menyiapkan Claude Code dengan akun Anthropic, Anda akan melihat config manual alih-alih ditimpa.

Setup Manual

Tambahkan ke ~/.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"
}

Lalu tambahkan "hasCompletedOnboarding": true ke ~/.claude.json untuk melewati setup wizard.

Fungsi Tiap Pengaturan

OpenCode

Gunakan Smart AIPI sebagai backend OpenCode Anda melalui SDK kompatibel OpenAI.

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

Codex CLI

Gunakan Smart AIPI dengan tool Codex CLI milik OpenAI. Tiga file perlu dikonfigurasi.

Setup Otomatis

npx smart-aipi codex

Ini akan mengonfigurasi ketiga file di bawah secara otomatis. Setelah dijalankan, tambahkan model_reasoning_effort ke config Anda (lihat langkah 2).

Setup Manual

Konfigurasikan tiga file ini:

1. API Key — ~/.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"

Level reasoning yang valid: low, medium, high (disarankan), xhigh.

3. Environment Variables — ~/.zshrc

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

Lalu gunakan Codex seperti biasa:

codex "fix this bug"

Panduan Kecepatan Codex WebSocket

Mode WebSocket biasanya lebih cepat untuk alur coding agentic dengan banyak tool call. Alih-alih berulang kali menyambung ulang lewat HTTP dan mengirim ulang envelope request penuh, Codex mempertahankan satu koneksi aktif dan mengirim giliran incremental, yang mengurangi overhead continuation.

Aktifkan WebSockets di Codex

Gunakan feature flag WebSocket v2 di ~/.codex/config.toml: ~/.codex/config.toml:

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

[features]
responses_websockets_v2 = true

Versi CLI yang setara:

codex --enable responses_websockets_v2

Build yang lebih lama mungkin menggunakan flag lawas:

[features]
responses_websockets = true

Perilaku Homebrew yang Diketahui

Pada beberapa build yang didistribusikan lewat Homebrew, giliran WebSocket bisa macet selama tugas berjalan lama lalu diam-diam fallback ke HTTP. Kami terutama melihat ini pada loop tool-call yang kompleks. Membangun ulang dari kode open-source dengan perbaikan di bawah meningkatkan stabilitas dan kecepatan.

Setelah Merge: Perbaiki Bug WebSocket Open-Source

Setelah merge branch Anda, gunakan checklist ini untuk memastikan perbaikannya ada di binary lokal Anda:

# 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

Jika Anda perlu melakukan patch manual, pastikan perbaikan level kode ini ada:

# 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

Gunakan Smart AIPI dengan Cursor IDE atau ekstensi Cline VS Code.

Chat

Gunakan Smart AIPI Chat di chat.smartaipi.com. untuk alur kerja teks, gambar, video, kode, pencarian, dan suara.

Fitur

• ✓ Chat — Percakapan teks serbaguna dengan model Smart AIPI.
• ✓ Gambar — Buat dan edit gambar dari prompt.
• ✓ Video — Buat video dari input teks atau gambar.
• ✓ Kode — Bantuan dan pengeditan kode di browser.
• ✓ Pencarian — Gunakan pencarian web untuk jawaban yang lebih grounded.
• ✓ Suara — Berbicara dengan model menggunakan input dan respons suara.

Memulai

Penagihan: Penggunaan ditagihkan ke kredit Smart AIPI Anda.

Penguji API

Uji API langsung dari browser Anda: