Dokumentasyon

Nagbibigay ang Smart AIPI ng parehong OpenAI at Anthropic-compatible APIs. Gamitin ang aming service sa kahit anong existing OpenAI o Anthropic SDK, tool, o app sa simpleng pagpapalit ng base URL. Walang kailangang baguhin sa code.

CLI at MCP Tools

Nagbibigay ang Smart AIPI ng dalawang npm packages para tulungan ang mga developer na magtrabaho sa kanilang accounts:

I-install ang Pareho

I-install nang Hiwa-hiwalay

Pagpapatunay

Lahat ng API requests ay nangangailangan ng API key. Gumagana ang parehong key sa dalawang authentication methods:

Gabay sa Migration

Mas mababa sa isang minuto ang migration. Ang aming API ay 100% compatible sa parehong OpenAI at Anthropic endpoints.

Mula sa OpenAI

Mula sa Anthropic

Chat Completions

Gumawa ng chat completion para sa ibinigay na mga messages at model. Ito ang pangunahing endpoint para makipag-interact sa language models.

Mga Parameter ng Request Body

Mga Message Role

Mga Code Example

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

I-enable ang streaming para makatanggap ng tokens habang ginagawa ang mga ito sa pamamagitan ng Server-Sent Events (SSE). Nagbibigay ito ng mas magandang user experience para sa mahahabang response.

Halimbawa ng 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 Effort

Kontrolin ang lalim ng reasoning gamit ang reasoning_effort parameter para sa GPT-5 models.

Mga Suportadong Model

Mga Reasoning Effort Level

Mabilis na Mode (Priority Processing)

Gamitin ang service_tier: "priority" para sa priority processing na mas mababa ang latency. Ito ang ginagamit ng /fast command sa Codex CLI. Hindi nito binabago ang lalim ng reasoning - pareho ang kalidad, mas mabilis lang.

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

API ng 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
)

Pagbuo ng Larawan

Gumawa ng images mula sa text prompts gamit ang aming image generation endpoint.

Mga Parameter ng Request Body

Mga Available na Model

Halimbawa

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

Pag-edit ng Larawan

Mag-edit ng mga existing image gamit ang text prompt. Tumatanggap ng parehong JSON (base64 string) at multipart/form-data (file upload), kaya gumagana agad ang OpenAI SDKs.

Mga Parameter ng Request Body

Halimbawa

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 na may WebSocket

WebSockets ay isang malawak na suportadong API para sa realtime data transfer, at magandang pagpipilian para sa pagkonekta sa Smart AIPI Realtime API sa server-to-server applications.

Sa isang server-to-server integration, kumokonekta ang iyong backend system via WebSocket direkta sa Realtime API. Gumamit ng standard na API key para i-authenticate ang connection, dahil available lang ang token sa iyong secure backend server.

Kumonekta via WebSocket

Nasa ibaba ang ilang halimbawa ng pagkonekta via WebSocket. Bukod sa paggamit ng WebSocket URL, kailangan mong magpasa ng authentication header gamit ang iyong 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: ...

Pagpapadala at Pagtanggap ng Events

Pinapamahalaan ang mga session gamit ang client-sent at server-sent JSON events sa WebSocket connection. I-wrap ang iyong request sa isang response.create envelope:

Ilista ang mga Model

Kunin ang listahan ng lahat ng available na models. Gamitin ang endpoint na ito para dynamically matuklasan kung aling models ang available para sa iyong account.

Format ng 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
    ]
}

Halimbawa

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"

Mga Available na Model

Anthropic Messages API

Buong compatibility sa Anthropic Messages API. Gamitin ang kahit anong Anthropic SDK, Claude Code, o app na nagsasalita ng Anthropic protocol - palitan lang ang base URL.

Mga Suportadong Feature

Mga Code Example

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

Pagmamapa ng Model

Tinatanggap ang mga Claude model name at awtomatikong iri-route sa GPT-5.4 na may tiered reasoning effort. Bawat response ay may kasamang x-actual-model header na nagpapakita ng totoong backend model.

Claude Code

Gamitin ang Claude Code kasama ang Smart AIPI bilang backend. Buong tool use, streaming, at agentic capabilities ay suportado.

Automatic na Setup

npx smart-aipi claude

Awtomatikong kino-configure nito ang ~/.claude/settings.json at ~/.claude.json . Kung naka-setup na ang Claude Code mo gamit ang Anthropic account, ipapakita nito ang manual config sa halip na i-overwrite.

Manual na Setup

Idagdag sa ~/.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"
}

Pagkatapos idagdag ang "hasCompletedOnboarding": true sa ~/.claude.json para laktawan ang setup wizard.

Ano ang Ginagawa ng Bawat Setting

OpenCode

Gamitin ang Smart AIPI bilang backend ng iyong OpenCode sa pamamagitan ng OpenAI-compatible SDK.

Pag-setup ng 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

Gamitin ang Smart AIPI kasama ang OpenAI's Codex CLI tool. Tatlong file ang kailangang i-configure.

Automatic na Setup

npx smart-aipi codex

Awtomatikong kino-configure nito ang lahat ng tatlong file sa ibaba. Pagkatapos tumakbo, idagdag ang model_reasoning_effort sa iyong config (tingnan ang step 2).

Manual na Setup

I-configure ang tatlong file na ito:

1. API Key — ~/.codex/auth.json

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

2. Model at Reasoning — ~/.codex/config.toml

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

Mga valid na reasoning level: low, medium, high (inirerekomenda), xhigh.

3. Environment Variables — ~/.zshrc

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

Pagkatapos, gamitin ang Codex nang normal:

codex "fix this bug"

Gabay sa Bilis ng Codex WebSocket

Karaniwang mas mabilis ang WebSocket mode para sa agentic coding flows na maraming tool calls. Sa halip na paulit-ulit na mag-reconnect sa HTTP at muling ipadala ang buong request envelopes, isang live connection lang ang pinananatili ng Codex at incremental turns ang ipinapadala, kaya nababawasan ang continuation overhead.

I-enable ang WebSockets sa Codex

Gamitin ang WebSocket v2 feature flag sa ~/.codex/config.toml: ~/.codex/config.toml:

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

[features]
responses_websockets_v2 = true

Katumbas sa CLI:

codex --enable responses_websockets_v2

Maaaring gamitin ng mas lumang builds ang legacy flag:

[features]
responses_websockets = true

Kilala na Homebrew Behavior

Sa ilang Homebrew-distributed builds, maaaring tumigil ang WebSocket turns habang mahahabang tasks at tahimik na babalik sa HTTP. Nakita namin ito lalo na sa mga kumplikadong tool-call loops. Ang pag-rebuild mula sa open-source code na may mga ayos sa ibaba ay nagpabuti sa stability at speed.

Pagkatapos ng Merge: Ayusin ang Open-Source WebSocket Bug

Pagkatapos i-merge ang branch mo, gamitin ang checklist na ito para matiyak na nasa local binary mo ang fix:

# 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

Kung kailangan mong mag-patch nang mano-mano, tiyaking naroon ang mga code-level fix na ito:

# 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 at Cline

Gamitin ang Smart AIPI kasama ang Cursor IDE o Cline VS Code extension.

Chat

Gamitin ang Smart AIPI Chat sa chat.smartaipi.com. para sa text, image, video, code, search, at voice workflows.

Mga Feature

• ✓ Chat — Pangkalahatang text conversations gamit ang Smart AIPI models.
• ✓ Mga Larawan — Gumawa at mag-edit ng images mula sa prompts.
• ✓ Video — Gumawa ng videos mula sa text o image inputs.
• ✓ Code — Code assistance at editing sa browser.
• ✓ Paghahanap — Gamitin ang web search para sa grounded answers.
• ✓ Boses — Kausapin ang model gamit ang voice input at responses.

Pagsisimula

Pagsingil: Ibi-bill ang usage laban sa iyong Smart AIPI credits.

Pang-subok ng API

Subukan ang API direkta mula sa iyong browser: