Dokumentacja

Smart AIPI udostępnia API kompatybilne zarówno z OpenAI, jak i Anthropic. Używaj naszej usługi z dowolnym istniejącym OpenAI lub Anthropic SDK, narzędziem albo aplikacją, po prostu zmieniając base URL. Bez zmian w kodzie.

Narzędzia CLI i MCP

Smart AIPI udostępnia dwa pakiety npm, które pomagają deweloperom pracować ze swoimi kontami:

Zainstaluj oba

Zainstaluj osobno

Uwierzytelnianie

Wszystkie żądania API wymagają API key. Ten sam klucz działa z obiema metodami uwierzytelniania:

Przewodnik migracji

Migracja zajmuje mniej niż minutę. Nasze API jest w 100% kompatybilne z endpointami OpenAI i Anthropic.

Z OpenAI

Z Anthropic

Chat Completions

Utwórz chat completion dla podanych wiadomości i modelu. To główny endpoint do interakcji z language models.

Parametry request body

Role wiadomości

Przykłady kodu

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

Włącz streaming, aby odbierać tokens w miarę ich generowania przez Server-Sent Events (SSE). Zapewnia to lepsze doświadczenie użytkownika przy długich odpowiedziach.

Przykład 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);
}

Wysiłek reasoning

Kontroluj głębokość reasoning za pomocą parametru reasoning_effort dla modeli GPT-5.

Obsługiwane modele

Poziomy wysiłku reasoning

Fast Mode (przetwarzanie priorytetowe)

Użyj service_tier: "priority" dla przetwarzania priorytetowego z niższym opóźnieniem. Tego właśnie używa polecenie /fast w Codex CLI. Nie zmienia to głębokości reasoning — otrzymujesz tę samą jakość, szybciej.

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

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

API Responses

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

Generowanie obrazów

Generuj obrazy z tekstowych prompts przy użyciu naszego endpoint do generowania obrazów.

Parametry request body

Dostępne modele

Przykład

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

Edycja obrazów

Edytuj istniejące obrazy za pomocą tekstowego prompt. Obsługuje zarówno JSON (ciąg base64), jak i multipart/form-data (upload pliku), więc OpenAI SDK działają od razu.

Parametry request body

Przykład

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 z WebSocket

WebSockets to szeroko wspierane API do transferu danych w czasie rzeczywistym i świetny wybór do łączenia ze Smart AIPI Realtime API w aplikacjach server-to-server.

W integracji server-to-server Twój system backend łączy się przez WebSocket bezpośrednio z Realtime API. Użyj standardowego API key do uwierzytelnienia połączenia, ponieważ token jest dostępny tylko na Twoim bezpiecznym serwerze backend.

Połącz przez WebSocket

Poniżej znajduje się kilka przykładów łączenia przez WebSocket. Oprócz użycia URL WebSocket musisz przekazać nagłówek uwierzytelniający z użyciem swojego 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: ...

Wysyłanie i odbieranie zdarzeń

Sesjami zarządza się za pomocą wysyłanych przez klienta i serwer zdarzeń JSON przez połączenie WebSocket. Owiń swoje żądanie w kopertę response.create :

Lista modeli

Pobierz listę wszystkich dostępnych modeli. Użyj tego endpoint, aby dynamicznie sprawdzać, które modele są dostępne dla Twojego konta.

Format odpowiedzi

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

Przykład

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"

Dostępne modele

Anthropic Messages API

Pełna kompatybilność z Anthropic Messages API. Używaj dowolnego Anthropic SDK, Claude Code lub aplikacji mówiącej protokołem Anthropic — wystarczy zmienić base URL.

Obsługiwane funkcje

Przykłady kodu

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

Mapowanie modeli

Nazwy modeli Claude są akceptowane i automatycznie kierowane do GPT-5.4 z warstwowym wysiłkiem reasoning. Każda odpowiedź zawiera x-actual-model header pokazujący rzeczywisty model backendu.

Claude Code

Używaj Claude Code ze Smart AIPI jako backendem. Pełne wsparcie dla tool use, streaming i możliwości agentowych.

Konfiguracja automatyczna

npx smart-aipi claude

To automatycznie skonfiguruje ~/.claude/settings.json i ~/.claude.json Jeśli masz już Claude Code skonfigurowane z kontem Anthropic, zobaczysz ręczną konfigurację zamiast nadpisania istniejących ustawień.

Konfiguracja ręczna

Dodaj do ~/.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"
}

Następnie dodaj "hasCompletedOnboarding": true do ~/.claude.json aby pominąć kreatora konfiguracji.

Co robi każde ustawienie

OpenCode

Używaj Smart AIPI jako backendu OpenCode przez SDK kompatybilne z OpenAI.

Konfiguracja 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

Używaj Smart AIPI z narzędziem OpenAI Codex CLI. Trzeba skonfigurować trzy pliki.

Konfiguracja automatyczna

npx smart-aipi codex

To automatycznie skonfiguruje wszystkie trzy pliki poniżej. Po uruchomieniu dodaj model_reasoning_effort do swojej konfiguracji (zobacz krok 2).

Konfiguracja ręczna

Skonfiguruj te trzy pliki:

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

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

2. Model i reasoning — ~/.codex/config.toml

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

Prawidłowe poziomy reasoning: low, medium, high (zalecane), xhigh.

3. Zmienne środowiskowe — ~/.zshrc

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

Następnie używaj Codex normalnie:

codex "fix this bug"

Przewodnik szybkości Codex WebSocket

Tryb WebSocket jest zwykle szybszy w agentowych przepływach kodowania z dużą liczbą wywołań narzędzi. Zamiast wielokrotnie ponownie łączyć się przez HTTP i wysyłać pełne koperty żądań, Codex utrzymuje jedno aktywne połączenie i wysyła przyrostowe tury, co zmniejsza narzut kontynuacji.

Włącz WebSockets w Codex

Użyj flagi funkcji WebSocket v2 w ~/.codex/config.toml: ~/.codex/config.toml:

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

[features]
responses_websockets_v2 = true

Odpowiednik w CLI:

codex --enable responses_websockets_v2

Starsze buildy mogą używać starszej flagi:

[features]
responses_websockets = true

Znane zachowanie Homebrew

W niektórych buildach dystrybuowanych przez Homebrew tury WebSocket mogą zawieszać się podczas długotrwałych zadań, a potem po cichu wracać do HTTP. Szczególnie widzieliśmy to w złożonych pętlach wywołań narzędzi. Ponowna kompilacja z otwartego kodu źródłowego z poprawkami poniżej poprawiła zarówno stabilność, jak i szybkość.

Po merge: napraw błąd WebSocket w open-source

Po zmergowaniu swojego brancha użyj tej checklisty, aby upewnić się, że poprawka znajduje się w lokalnym binarium:

# 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

Jeśli musisz ręcznie nałożyć poprawki, sprawdź, czy obecne są te poprawki na poziomie kodu:

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

Używaj Smart AIPI z Cursor IDE albo rozszerzeniem Cline do VS Code.

Czat

Używaj Smart AIPI Chat pod adresem chat.smartaipi.com. do pracy z tekstem, obrazami, wideo, kodem, wyszukiwaniem i głosem.

Funkcje

• ✓ Czat — Uniwersalne rozmowy tekstowe z modelami Smart AIPI.
• ✓ Obrazy — Generuj i edytuj obrazy na podstawie prompts.
• ✓ Wideo — Generuj wideo z tekstu lub obrazów wejściowych.
• ✓ Kod — Pomoc z kodem i edycja w przeglądarce.
• ✓ Wyszukiwanie — Użyj wyszukiwania w sieci, aby uzyskać odpowiedzi oparte na źródłach.
• ✓ Głos — Rozmawiaj z modelem za pomocą wejścia głosowego i odpowiedzi głosowych.

Pierwsze kroki

Rozliczenia: Użycie jest rozliczane z Twoich kredytów Smart AIPI.

Tester API

Przetestuj API bezpośrednio z przeglądarki: