Dokümantasyon

Smart AIPI hem OpenAI hem de Anthropic uyumlu API'ler sunar. Mevcut herhangi bir OpenAI veya Anthropic SDK, aracı ya da uygulamasıyla sadece base URL'yi değiştirerek hizmetimizi kullanın. Hiç kod değişikliği gerekmez.

CLI ve MCP Araçları

Smart AIPI, geliştiricilerin hesaplarıyla çalışmasına yardımcı olmak için iki npm paketi sunar:

İkisini de Kur

Ayrı Ayrı Kur

Kimlik Doğrulama

Tüm API istekleri bir API key gerektirir. Aynı anahtar her iki kimlik doğrulama yöntemiyle de çalışır:

Geçiş Rehberi

Geçiş bir dakikadan az sürer. API'miz hem OpenAI hem de Anthropic endpoint'leriyle %100 uyumludur.

OpenAI'den

Anthropic'ten

Chat Completions

Verilen mesajlar ve model için bir chat completion oluşturun. Bu, dil modelleriyle etkileşim kurmak için ana endpoint'tir.

İstek Gövdesi Parametreleri

Mesaj Rolleri

Kod Örnekleri

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

Akış

Server-Sent Events (SSE) üzerinden oluşturuldukça tokens almak için streaming'i etkinleştirin. Bu, uzun yanıtlar için daha iyi bir kullanıcı deneyimi sağlar.

Streaming Örneği

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

Akıl Yürütme Çabası

Akıl yürütme derinliğini reasoning_effort GPT-5 modelleri için parametresiyle kontrol edin.

Desteklenen Modeller

Reasoning Effort Seviyeleri

Hızlı Mod (Öncelikli İşleme)

Şunu kullanın: service_tier: "priority" daha düşük gecikmeyle öncelikli işleme için. Codex CLI'deki /fast komutunun kullandığı şey budur. Reasoning derinliğini değiştirmez - aynı kaliteyi daha hızlı alırsınız.

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
)

Görsel Oluşturma

Görsel oluşturma endpoint'imizi kullanarak metin prompt'larından görseller oluşturun.

İstek Gövdesi Parametreleri

Mevcut Modeller

Örnek

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

Görsel Düzenlemeleri

Bir metin prompt kullanarak mevcut görselleri düzenleyin. Hem JSON (base64 string) hem de multipart/form-data (dosya yükleme) kabul eder, böylece OpenAI SDK'leri doğrudan çalışır.

İstek Gövdesi Parametreleri

Örnek

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 ile Realtime API

WebSocket'ler WebSockets, realtime veri aktarımı için geniş destek gören bir API'dir ve sunucudan sunucuya uygulamalarda Smart AIPI Realtime API'ye bağlanmak için harika bir seçenektir.

Sunucudan sunucuya bir entegrasyonda, backend sisteminiz Realtime API'ye doğrudan WebSocket üzerinden bağlanır. Bağlantıyı doğrulamak için standart bir API anahtarı kullanın; çünkü token yalnızca güvenli backend sunucunuzda bulunur.

WebSocket ile Bağlan

Aşağıda WebSocket ile bağlanmaya dair birkaç örnek bulunuyor. WebSocket URL'yi kullanmanın yanında, API key'nizi kullanarak bir authentication header geçirmeniz de gerekir.

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

Event Gönderme ve Alma

Oturumlar, WebSocket bağlantısı üzerinden istemci tarafından gönderilen ve sunucu tarafından gönderilen JSON event'ler ile yönetilir. İsteğinizi bir response.create zarfı içinde sarın:

Modelleri Listele

Mevcut tüm modellerin bir listesini alın. Hesabınız için hangi modellerin kullanılabildiğini dinamik olarak keşfetmek için bu endpoint'i kullanın.

Yanıt Formatı

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

Örnek

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"

Mevcut Modeller

Anthropic Messages API

Tam Anthropic Messages API uyumluluğu. Anthropic SDK, Claude Code veya Anthropic protokolünü konuşan herhangi bir uygulamayı kullanın - sadece base URL'yi değiştirin.

Desteklenen Özellikler

Kod Örnekleri

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

Model Eşleme

Claude model adları kabul edilir ve kademeli reasoning effort ile otomatik olarak GPT-5.4'e yönlendirilir. Her yanıt, x-actual-model gerçek backend modelini gösteren bir header içerir.

Claude Code

Claude Code'u backend olarak Smart AIPI ile kullanın. Tam araç kullanımı, streaming ve agentic yetenekler desteklenir.

Otomatik Kurulum

npx smart-aipi claude

Bu işlem ~/.claude/settings.json ve ~/.claude.json ayarını otomatik olarak yapılandırır. Eğer Claude Code'u zaten bir Anthropic hesabıyla kurduysanız, üzerine yazmak yerine size manuel yapılandırmayı gösterir.

Manuel Kurulum

Şuraya ekleyin: ~/.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"
}

Ardından "hasCompletedOnboarding": true içine ~/.claude.json ekleyerek kurulum sihirbazını atlayın.

Her Ayar Ne İşe Yarar

OpenCode

OpenAI uyumlu SDK üzerinden Smart AIPI'yi OpenCode backend'iniz olarak kullanın.

Yapılandırma Kurulumu

{
  "$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'yi OpenAI'nin Codex CLI aracıyla kullanın. Üç dosyanın yapılandırılması gerekir.

Otomatik Kurulum

npx smart-aipi codex

Bu işlem aşağıdaki üç dosyanın tamamını otomatik olarak yapılandırır. Çalıştırdıktan sonra, yapılandırmanıza model_reasoning_effort ekleyin (2. adıma bakın).

Manuel Kurulum

Bu üç dosyayı yapılandırın:

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

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

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

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

Geçerli reasoning seviyeleri: low, medium, high (önerilen), xhigh.

3. Ortam Değişkenleri — ~/.zshrc

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

Ardından Codex'i normal şekilde kullanın:

codex "fix this bug"

Codex WebSocket Hız Rehberi

Çok sayıda araç çağrısı içeren agentic kodlama akışları için WebSocket modu genellikle daha hızlıdır. Codex, HTTP üzerinden tekrar tekrar yeniden bağlanıp tam istek zarflarını yeniden göndermek yerine tek bir canlı bağlantıyı korur ve artımlı dönüşler gönderir; bu da continuation ek yükünü azaltır.

Codex'te WebSockets'i Etkinleştirin

~/.codex/config.toml içinde WebSocket v2 feature flag kullanın: ~/.codex/config.toml:

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

[features]
responses_websockets_v2 = true

CLI karşılığı:

codex --enable responses_websockets_v2

Eski sürümler legacy flag kullanabilir:

[features]
responses_websockets = true

Bilinen Homebrew Davranışı

Bazı Homebrew dağıtımlı sürümlerde, WebSocket dönüşleri uzun süren görevlerde takılabiliyor ve ardından sessizce HTTP'ye geri düşebiliyor. Bunu özellikle karmaşık tool-call döngülerinde gördük. Aşağıdaki düzeltmelerle açık kaynak koddan yeniden derlemek hem kararlılığı hem de hızı iyileştirdi.

Birleştirme Sonrası: Açık Kaynak WebSocket Hatasını Düzeltin

Branch'inizi birleştirdikten sonra, düzeltmenin yerel binary'nizde olduğundan emin olmak için bu kontrol listesini kullanın:

# 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

Manuel olarak yama uygulamanız gerekiyorsa, bu kod düzeyindeki düzeltmelerin mevcut olduğunu doğrulayın:

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

Smart AIPI'yi Cursor IDE veya Cline VS Code uzantısıyla kullanın.

Chat

Smart AIPI Chat'i şurada kullanın: chat.smartaipi.com. metin, görsel, video, kod, arama ve ses iş akışları için.

Özellikler

• ✓ Chat — Smart AIPI modelleriyle genel amaçlı metin konuşmaları.
• ✓ Görseller — Prompt'lardan görseller oluşturun ve düzenleyin.
• ✓ Video — Metin veya görsel girdilerden video oluşturun.
• ✓ Kod — Tarayıcıda kod yardımı ve düzenleme.
• ✓ Arama — Dayanaklı yanıtlar için web aramasını kullanın.
• ✓ Ses — Sesli giriş ve yanıtlarla modelle konuşun.

Başlangıç

Faturalama: Kullanım, Smart AIPI kredilerinizden ücretlendirilir.

API Test Aracı

API'yi doğrudan tarayıcınızdan test edin: