Documentation

Smart AIPI fournit des API compatibles OpenAI et Anthropic. Utilisez notre service avec n'importe quel SDK, outil ou application OpenAI ou Anthropic existant en changeant simplement la base URL. Aucun changement de code nécessaire.

Outils CLI et MCP

Smart AIPI fournit deux packages npm pour aider les développeurs à travailler avec leurs comptes :

Installer les deux

Installer séparément

Authentification

Toutes les requêtes API nécessitent une API key. La même clé fonctionne avec les deux méthodes d'authentification :

Guide de migration

La migration prend moins d'une minute. Notre API est 100 % compatible avec les endpoints OpenAI et Anthropic.

Depuis OpenAI

Depuis Anthropic

Achèvements des discussions

Créez une chat completion pour les messages et le modèle fournis. C'est le principal endpoint pour interagir avec les modèles de langage.

Paramètres du corps de la requête

Rôles des messages

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

Streaming

Activez le streaming pour recevoir les tokens au fur et à mesure de leur génération via les Server-Sent Events (SSE). Cela offre une meilleure expérience utilisateur pour les réponses longues.

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

Effort de reasoning

Contrôlez la profondeur du reasoning avec le paramètre reasoning_effort pour les modèles GPT-5.

Modèles pris en charge

Niveaux d'effort de reasoning

Mode rapide (traitement prioritaire)

Utilisez service_tier: "priority" pour un traitement prioritaire avec une latence plus faible. C'est ce qu'utilise la commande /fast dans Codex CLI. Cela ne change pas la profondeur de reasoning - vous obtenez la même qualité, plus rapidement.

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
)

Génération d'images

Générez des images à partir de prompts textuels à l'aide de notre endpoint de génération d'images.

Paramètres du corps de la requête

Modèles disponibles

Exemple

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

Modifications d'image

Modifiez des images existantes à l'aide d'un prompt textuel. Accepte à la fois JSON (chaîne base64) et multipart/form-data (upload de fichier), pour que les SDK OpenAI fonctionnent immédiatement.

Paramètres du corps de la requête

Exemple

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

WebSockets sont une API largement prise en charge pour le transfert de données en temps réel, et un excellent choix pour se connecter à la Realtime API de Smart AIPI dans les applications serveur à serveur.

Dans une intégration serveur à serveur, votre système backend se connecte via WebSocket directement à la Realtime API. Utilisez un Touche API standard pour authentifier la connexion, car le token n'est disponible que sur votre serveur backend sécurisé.

Se connecter via WebSocket

Vous trouverez ci-dessous plusieurs exemples de connexion via WebSocket. En plus d'utiliser l'URL WebSocket, vous devrez transmettre un en-tête d'authentification avec votre 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: ...

Envoi et réception d'événements

Les sessions sont gérées à l'aide d'événements JSON envoyés par le client et le serveur via la connexion WebSocket. Encapsulez votre requête dans une enveloppe response.create :

Lister les modèles

Récupérez la liste de tous les modèles disponibles. Utilisez cet endpoint pour découvrir dynamiquement quels modèles sont disponibles pour votre compte.

Format de réponse

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

Exemple

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"

Modèles disponibles

API Messages d'Anthropic

Compatibilité complète avec l'Anthropic Messages API. Utilisez n'importe quel SDK Anthropic, Claude Code ou application parlant le protocole Anthropic - changez simplement la base URL.

Fonctionnalités prises en charge

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

Correspondance des modèles

Les noms de modèles Claude sont acceptés et automatiquement routés vers GPT-5.4 avec un effort de reasoning par niveaux. Chaque réponse inclut un en-tête x-actual-model indiquant le vrai modèle backend.

Claude Code

Utilisez Claude Code avec Smart AIPI comme backend. Utilisation complète des outils, streaming et capacités agentiques pris en charge.

Configuration automatique

npx smart-aipi claude

Cela configure ~/.claude/settings.json et ~/.claude.json automatiquement. Si Claude Code est déjà configuré avec un compte Anthropic, la configuration manuelle vous sera affichée au lieu d'écraser l'existant.

Configuration manuelle

Ajoutez à ~/.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"
}

Ajoutez ensuite "hasCompletedOnboarding": true à ~/.claude.json pour ignorer l'assistant de configuration.

À quoi sert chaque paramètre

OpenCode

Utilisez Smart AIPI comme backend OpenCode via le SDK compatible OpenAI.

Configuration du 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

Utilisez Smart AIPI avec l'outil Codex CLI d'OpenAI. Trois fichiers doivent être configurés.

Configuration automatique

npx smart-aipi codex

Cela configure automatiquement les trois fichiers ci-dessous. Après l'exécution, ajoutez model_reasoning_effort à votre configuration (voir étape 2).

Configuration manuelle

Configurez ces trois fichiers :

1. Clé API — ~/.codex/auth.json

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

2. Modèle et reasoning — ~/.codex/config.toml

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

Niveaux de reasoning valides : low, medium, high (recommandé), xhigh.

3. Variables d'environnement — ~/.zshrc

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

Ensuite, utilisez Codex normalement :

codex "fix this bug"

Guide de vitesse Codex WebSocket

Le mode WebSocket est généralement plus rapide pour les flux de code agentiques avec beaucoup d'appels d'outils. Au lieu de se reconnecter sans cesse via HTTP et de renvoyer des enveloppes de requête complètes, Codex conserve une connexion active unique et envoie des tours incrémentaux, ce qui réduit la surcharge de continuation.

Activer WebSockets dans Codex

Utilisez le feature flag WebSocket v2 dans ~/.codex/config.toml : ~/.codex/config.toml:

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

[features]
responses_websockets_v2 = true

Équivalent CLI :

codex --enable responses_websockets_v2

Les anciennes builds peuvent utiliser le flag legacy :

[features]
responses_websockets = true

Comportement connu avec Homebrew

Sur certaines builds distribuées via Homebrew, les tours WebSocket peuvent se bloquer pendant les tâches longues puis repasser silencieusement sur HTTP. Nous l'avons observé surtout dans des boucles complexes d'appels d'outils. Recompiler à partir du code open source avec les correctifs ci-dessous a amélioré à la fois la stabilité et la vitesse.

Après la fusion : corriger le bug WebSocket open source

Après avoir fusionné votre branche, utilisez cette checklist pour vous assurer que le correctif est bien présent dans votre binaire local :

# 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

Si vous devez appliquer le patch manuellement, vérifiez que ces correctifs au niveau du code sont présents :

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

Utilisez Smart AIPI avec Cursor IDE ou l'extension VS Code Cline.

Chat

Utilisez Smart AIPI Chat sur chat.smartaipi.com. pour les workflows texte, image, vidéo, code, recherche et voix.

Fonctionnalités

• ✓ Chat — Conversations textuelles générales avec les modèles Smart AIPI.
• ✓ Images — Générez et modifiez des images à partir de prompts.
• ✓ Vidéo — Générez des vidéos à partir de texte ou d'images.
• ✓ Code — Assistance et édition de code dans le navigateur.
• ✓ Recherche — Utilisez la recherche web pour obtenir des réponses fondées.
• ✓ Voix — Parlez au modèle avec une entrée vocale et des réponses vocales.

Premiers pas

Facturation : L'utilisation est facturée sur vos crédits Smart AIPI.

Testeur API

Testez l'API directement depuis votre navigateur :