डॉक्यूमेंटेशन

Smart AIPI OpenAI और Anthropic-compatible APIs दोनों प्रदान करता है। बस base URL बदलकर हमारे service को किसी भी मौजूदा OpenAI या Anthropic SDK, tool, या app के साथ उपयोग करें। Zero code changes required.

CLI और MCP Tools

Smart AIPI developers को अपने accounts के साथ काम करने में मदद करने के लिए दो npm packages प्रदान करता है:

दोनों इंस्टॉल करें

अलग-अलग इंस्टॉल करें

ऑथेंटिकेशन

सभी API requests के लिए एक API key आवश्यक है। वही key दोनों authentication methods के साथ काम करती है:

माइग्रेशन गाइड

Migration में एक मिनट से भी कम समय लगता है। हमारी API OpenAI और Anthropic endpoints दोनों के साथ 100% compatible है।

OpenAI से

Anthropic से

Chat Completions

दिए गए messages और model के लिए chat completion बनाएं। भाषा models के साथ इंटरैक्ट करने के लिए यह मुख्य endpoint है।

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

स्ट्रीमिंग

generate होते समय tokens को Server-Sent Events (SSE) के ज़रिए प्राप्त करने के लिए streaming सक्षम करें। यह लंबी responses के लिए बेहतर user experience देता है।

स्ट्रीमिंग उदाहरण

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 के लिए करें।

समर्थित मॉडल्स

तर्क प्रयास स्तर

फास्ट मोड (प्राथमिकता प्रोसेसिंग)

उपयोग करें service_tier: "priority" priority processing के लिए, कम latency के साथ। यही वह है जिसे 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 से images generate करें।

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 का उपयोग करके मौजूदा images edit करें। यह 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 के लिए व्यापक रूप से supported API हैं, और server-to-server applications में Smart AIPI Realtime API से connect करने के लिए एक शानदार विकल्प हैं।

server-to-server integration में, आपका backend system सीधे Realtime API से WebSocket के ज़रिए connect करता है। connection authenticate करने के लिए एक standard API कुंजी का उपयोग करें, क्योंकि token केवल आपके secure backend server पर उपलब्ध होता है।

WebSocket के ज़रिए connect करें

नीचे WebSocket के ज़रिए connect करने के कई examples हैं। 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 के ज़रिए manage किए जाते हैं। अपनी request को एक response.create envelope में wrap करें:

Models की सूची

सभी उपलब्ध models की सूची प्राप्त करें। अपने account के लिए उपलब्ध models को dynamically discover करने के लिए इस 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, या ऐसे app का उपयोग करें जो 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 model names स्वीकार किए जाते हैं और अपने आप tiered reasoning effort के साथ GPT-5.4 पर route हो जाते हैं। हर response में एक x-actual-model header होता है जो वास्तविक backend model दिखाता है।

Claude Code

Smart AIPI को backend के रूप में Claude Code के साथ उपयोग करें। पूरा tool use, streaming, और agentic capabilities supported हैं।

स्वचालित सेटअप

npx smart-aipi claude

यह ~/.claude/settings.json और ~/.claude.json को अपने आप कॉन्फ़िगर करता है। यदि आपके पास पहले से Anthropic account के साथ Claude Code सेट है, तो 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 को skip करने के लिए।

हर Setting क्या करती है

OpenCode

OpenAI-compatible SDK के ज़रिए Smart AIPI को अपने OpenCode backend के रूप में उपयोग करें।

कॉन्फ़िग सेटअप

{
  "$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

Smart AIPI को OpenAI के Codex CLI tool के साथ उपयोग करें। तीन files कॉन्फ़िगर करनी होंगी।

स्वचालित सेटअप

npx smart-aipi codex

यह नीचे दी गई तीनों files को अपने आप कॉन्फ़िगर करता है। चलाने के बाद, अपनी config में model_reasoning_effort जोड़ें (step 2 देखें)।

मैन्युअल सेटअप

इन तीन files को कॉन्फ़िगर करें:

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 levels: 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 स्पीड गाइड

बहुत सारे 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 करना है, तो verify करें कि ये 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

Smart AIPI को Cursor IDE या Cline VS Code extension के साथ उपयोग करें।

चैट

Smart AIPI Chat का उपयोग करें chat.smartaipi.com. text, image, video, code, search, और voice workflows के लिए।

फ़ीचर्स

• ✓ चैट — Smart AIPI models के साथ सामान्य उद्देश्य वाले text conversations।
• ✓ इमेजेज — prompts से images generate और edit करें।
• ✓ वीडियो — text या image inputs से videos generate करें।
• ✓ कोड — browser में code सहायता और editing।
• ✓ सर्च — grounded answers के लिए web search का उपयोग करें।
• ✓ वॉइस — voice input और responses के साथ model से बात करें।

शुरुआत करें

बिलिंग: उपयोग का बिल आपके Smart AIPI credits से लिया जाता है।

API परीक्षक

अपने browser से सीधे API टेस्ट करें: