ஆவணங்கள்

Smart AIPI OpenAI மற்றும் Anthropic-compatible APIs இரண்டையும் வழங்குகிறது. base URL ஐ மட்டும் மாற்றி, ஏற்கனவே உள்ள OpenAI அல்லது Anthropic SDK, tool, அல்லது app உடன் எங்கள் service ஐ பயன்படுத்துங்கள். code changes தேவையில்லை.

CLI & MCP கருவிகள்

developers க்கு தங்கள் accounts உடன் வேலை செய்ய Smart AIPI இரண்டு npm packages வழங்குகிறது:

இரண்டையும் நிறுவவும்

தனித்தனியாக நிறுவவும்

அங்கீகாரம்

அனைத்து API requests களுக்கும் ஒரு API key தேவை. அதே key இரண்டு authentication முறைகளிலும் வேலை செய்யும்:

மைக்ரேஷன் வழிகாட்டி

Migration செய்ய ஒரு நிமிடத்திற்கும் குறைவாகும். எங்கள் API OpenAI மற்றும் Anthropic endpoints இரண்டுடனும் 100% compatible.

OpenAI இலிருந்து

Anthropic இலிருந்து

Chat Completions

கொடுக்கப்பட்ட messages மற்றும் model க்காக ஒரு chat completion உருவாக்கவும். language models உடன் தொடர்பு கொள்ள இதுவே முக்கிய endpoint.

Request Body அளவுருக்கள்

செய்தி பங்குகள்

Code எடுத்துக்காட்டுகள்

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

ஸ்ட்ரீமிங்

Server-Sent Events (SSE) மூலம் உருவாக்கப்படும் போதே tokens ஐ பெற streaming ஐ இயலுமைப்படுத்துங்கள். நீண்ட responses க்கு இது சிறந்த user experience ஐ வழங்கும்.

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 GPT-5 மாடல்களுக்கு parameter ஐ பயன்படுத்தவும்.

ஆதரிக்கப்படும் Models

Reasoning Effort நிலைகள்

Fast Mode (முன்னுரிமை செயலாக்கம்)

பயன்படுத்தவும் service_tier: "priority" ஐ lower latency உடன் priority processing க்காக பயன்படுத்தவும். இதையே Codex CLI இல் உள்ள /fast command பயன்படுத்துகிறது. இது reasoning depth ஐ மாற்றாது - அதே தரம், இன்னும் வேகமாக கிடைக்கும்.

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

Chat Completions 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
)

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
)

பட உருவாக்கம்

எங்கள் image generation endpoint ஐ பயன்படுத்தி text prompts இலிருந்து படங்களை உருவாக்குங்கள்.

Request Body அளவுருக்கள்

கிடைக்கும் Models

எடுத்துக்காட்டு

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 string) மற்றும் multipart/form-data (file upload) இரண்டையும் ஏற்கிறது; அதனால் 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"

WebSocket உடன் Realtime API

WebSockets realtime data transfer க்காக பரவலாக ஆதரிக்கப்படும் API ஆகும்; server-to-server applications இல் Smart AIPI Realtime API உடன் இணைவதற்கான சிறந்த தேர்வு.

server-to-server integration இல், உங்கள் backend system Realtime API உடன் நேரடியாக WebSocket மூலம் இணைகிறது. connection ஐ authenticate செய்ய ஒரு standard API விசை ஐ பயன்படுத்தவும், ஏனெனில் token உங்கள் பாதுகாப்பான backend server இல் மட்டும் கிடைக்கும்.

WebSocket மூலம் இணைக

கீழே WebSocket மூலம் இணைவதற்கான பல எடுத்துக்காட்டுகள் உள்ளன. WebSocket URL ஐ பயன்படுத்துவதற்கு கூடுதலாக, உங்கள் API key ஐ பயன்படுத்தி authentication header ஐ அனுப்ப வேண்டும்.

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, WebSocket connection வழியாக client-sent மற்றும் server-sent JSON events மூலம் நிர்வகிக்கப்படுகின்றன. உங்கள் request ஐ ஒரு response.create envelope இல் wrap செய்யுங்கள்:

Models பட்டியல்

கிடைக்கும் அனைத்து models இன் பட்டியலை பெறுங்கள். உங்கள் account க்கு எந்த models கிடைக்கின்றன என்பதை dynamic ஆக கண்டறிய இந்த endpoint ஐ பயன்படுத்துங்கள்.

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"

கிடைக்கும் Models

Anthropic Messages API

முழு Anthropic Messages API compatibility. எந்த Anthropic SDK, Claude Code, அல்லது Anthropic protocol பேசும் app ஆனாலும் பயன்படுத்தலாம் - base URL ஐ மட்டும் மாற்றுங்கள்.

ஆதரிக்கப்படும் அம்சங்கள்

Code எடுத்துக்காட்டுகள்

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 model names ஏற்கப்படுகின்றன மற்றும் tiered reasoning effort உடன் GPT-5.4 க்கு தானாக route செய்யப்படுகின்றன. ஒவ்வொரு response இலும் உண்மையான backend model ஐ காட்டும் ஒரு x-actual-model header இருக்கும்.

Claude Code

Smart AIPI ஐ backend ஆக வைத்து Claude Code ஐ பயன்படுத்துங்கள். முழு tool use, streaming, மற்றும் agentic capabilities ஆதரிக்கப்படுகின்றன.

தானியங்கி அமைப்பு

npx smart-aipi claude

இது ~/.claude/settings.json மற்றும் ~/.claude.json ஐ தானாக அமைக்கும். நீங்கள் ஏற்கனவே Claude Code ஐ Anthropic account உடன் அமைத்திருந்தால், overwrite செய்யாமல் manual config ஐ காட்டும்.

கைமுறை அமைப்பு

இதில் சேர்க்கவும் ~/.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 ஐ தவிர்க்கவும்.

ஒவ்வொரு Setting என்ன செய்கிறது

OpenCode

OpenAI-compatible SDK மூலம் Smart AIPI ஐ உங்கள் OpenCode backend ஆக பயன்படுத்துங்கள்.

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

OpenAI இன் Codex CLI tool உடன் Smart AIPI ஐ பயன்படுத்துங்கள். மூன்று files ஐ அமைக்க வேண்டும்.

தானியங்கி அமைப்பு

npx smart-aipi codex

இது கீழே உள்ள மூன்று files ஐ தானாக அமைக்கும். இயக்கிய பிறகு, model_reasoning_effort ஐ உங்கள் config இல் சேர்க்கவும் (படி 2 ஐ பார்க்கவும்).

கைமுறை அமைப்பு

இந்த மூன்று files ஐ அமைக்கவும்:

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

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

2. மாடல் மற்றும் ரீஸனிங் — ~/.codex/config.toml

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

செல்லுபடியாகும் reasoning levels: low, medium, high (பரிந்துரைக்கப்படுகிறது), xhigh.

3. Environment Variables — ~/.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 வேக வழிகாட்டி

அதிக tool calls உள்ள agentic coding flows க்கு WebSocket mode பொதுவாக வேகமாக இருக்கும். HTTP வழியாக மீண்டும் மீண்டும் reconnect செய்து முழு request envelopes ஐ மீண்டும் அனுப்புவதற்குப் பதிலாக, Codex ஒரு live connection ஐ வைத்துக்கொண்டு incremental turns ஐ அனுப்பும்; இதனால் continuation overhead குறையும்.

Codex இல் WebSockets ஐ இயலுமைப்படுத்துங்கள்

~/.codex/config.toml இல் WebSocket v2 feature flag ஐ பயன்படுத்தவும்: ~/.codex/config.toml:

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

[features]
responses_websockets_v2 = true

CLI இணைவு:

codex --enable responses_websockets_v2

பழைய builds இல் legacy flag பயன்படுத்தப்படலாம்:

[features]
responses_websockets = true

அறியப்பட்ட Homebrew நடத்தை

சில Homebrew-distributed builds இல், நீண்ட நேரம் ஓடும் tasks போது WebSocket turns நின்றுவிட்டு, பின்னர் அமைதியாக HTTP க்கு fallback ஆகலாம். குறிப்பாக complex tool-call loops இல் இதைப் பார்த்தோம். கீழே உள்ள fixes உடன் open-source code இலிருந்து rebuild செய்தபோது stability மற்றும் speed இரண்டும் மேம்பட்டன.

Post-Merge: Open-Source WebSocket Bug ஐ சரிசெய்யவும்

உங்கள் branch ஐ merge செய்த பிறகு, இந்த 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

நீங்கள் manual patch செய்ய வேண்டுமெனில், இந்த code-level fixes உள்ளனவா என்று உறுதி செய்யவும்:

# 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

Cursor IDE அல்லது Cline VS Code extension உடன் Smart AIPI ஐ பயன்படுத்துங்கள்.

அரட்டை

Smart AIPI Chat ஐ பயன்படுத்துங்கள் chat.smartaipi.com. இல் text, image, video, code, search, மற்றும் voice workflows க்காக.

அம்சங்கள்

• ✓ அரட்டை — Smart AIPI models உடன் பொதுப் பயன்பாட்டு text conversations.
• ✓ படங்கள் — prompts மூலம் படங்களை உருவாக்கவும் மற்றும் திருத்தவும்.
• ✓ வீடியோ — text அல்லது image inputs இலிருந்து videos உருவாக்கவும்.
• ✓ கோடு — browser இல் code உதவி மற்றும் திருத்தம்.
• ✓ தேடல் — grounded answers க்காக web search ஐ பயன்படுத்தவும்.
• ✓ குரல் — voice input மற்றும் responses மூலம் model உடன் பேசுங்கள்.

தொடங்குவது எப்படி

கட்டணம்: Usage உங்கள் Smart AIPI credits இற்கு எதிராக bill செய்யப்படும்.

API சோதிப்பான்

உங்கள் browser இலிருந்தே API ஐ சோதிக்கவும்: