డాక్యుమెంటేషన్

Smart AIPI OpenAI మరియు Anthropic-compatible APIs రెండింటినీ అందిస్తుంది. ఉన్న OpenAI లేదా Anthropic SDK, tool, లేదా app తో base URL మాత్రమే మార్చి మా సేవను ఉపయోగించండి. code మార్పులు అవసరం లేదు.

CLI & MCP టూల్స్

Smart AIPI డెవలపర్లు వారి ఖాతాలతో పని చేయడానికి సహాయపడే రెండు npm packages ను అందిస్తుంది:

రెండింటినీ ఇన్‌స్టాల్ చేయండి

వేర్వేరుగా ఇన్‌స్టాల్ చేయండి

ప్రామాణీకరణ

అన్ని API requests కు ఒక API key అవసరం. అదే key రెండు authentication methods తో కూడా పనిచేస్తుంది:

మైగ్రేషన్ గైడ్

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) ద్వారా generate అవుతున్నప్పుడు 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 లోతును నియంత్రించండి reasoning_effort parameter ను GPT-5 models కోసం.

మద్దతు ఉన్న Models

Reasoning Effort స్థాయులు

Fast Mode (ప్రాధాన్య ప్రాసెసింగ్)

ఉపయోగించండి service_tier: "priority" ని తక్కువ latency తో priority processing కోసం ఉపయోగించండి. Codex CLI లోని /fast command ఇదే ఉపయోగిస్తుంది. ఇది reasoning depth ను మార్చదు - అదే quality, మరింత వేగంగా పొందుతారు.

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 WebSocket ద్వారా నేరుగా Realtime API కి కనెక్ట్ అవుతుంది. కనెక్షన్ authenticate చేయడానికి ఒక standard API కీ ను ఉపయోగించండి, ఎందుకంటే token మీ secure 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 మాత్రమే మార్చండి.

మద్దతు ఉన్న Features

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

backend గా Smart AIPI తో Claude Code ఉపయోగించండి. పూర్తి tool use, streaming, మరియు agentic capabilities కి మద్దతు ఉంది.

ఆటోమేటిక్ Setup

npx smart-aipi claude

ఇది ~/.claude/settings.json మరియు ~/.claude.json ను స్వయంచాలకంగా కాన్ఫిగర్ చేస్తుంది. మీకు ఇప్పటికే Anthropic account తో Claude Code సెటప్ అయి ఉంటే, overwrite చేయకుండా manual config చూపిస్తుంది.

మాన్యువల్ Setup

ఇదిలో చేర్చండి ~/.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 కాన్ఫిగర్ చేయాలి.

ఆటోమేటిక్ Setup

npx smart-aipi codex

ఇది క్రింద ఉన్న మూడు files అన్నింటినీ స్వయంచాలకంగా కాన్ఫిగర్ చేస్తుంది. run చేసిన తర్వాత, మీ config లో model_reasoning_effort ని జోడించండి (step 2 చూడండి).

మాన్యువల్ Setup

ఈ మూడు 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 లో, దీర్ఘకాలిక పనుల సమయంలో WebSocket turns stall అయి, తర్వాత నిశ్శబ్దంగా HTTP కి fallback అవుతాయి. ముఖ్యంగా క్లిష్టమైన tool-call loops లో ఇది ఎక్కువగా కనిపించింది. క్రింద ఉన్న fixes తో open-source code నుండి rebuild చేయడం స్థిరత్వం మరియు వేగం రెండింటినీ మెరుగుపరిచింది.

Post-Merge: Open-Source WebSocket Bug ను సరిచేయండి

మీ branch merge చేసిన తర్వాత, fix మీ local binary లో ఉందని నిర్ధారించడానికి ఈ checklist ను ఉపయోగించండి:

# 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

మీరు manually 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 నుండి వీడియోలను సృష్టించండి.
• ✓ కోడ్ — browser లో code సహాయం మరియు editing.
• ✓ శోధన — grounded answers కోసం web search ఉపయోగించండి.
• ✓ వాయిస్ — voice input మరియు responses తో model తో మాట్లాడండి.

ప్రారంభించడం

బిల్లింగ్: Usage మీ Smart AIPI credits పై బిల్లు అవుతుంది.

API టెస్టర్

మీ browser నుంచే API ని నేరుగా పరీక్షించండి: