Documentación

Smart AIPI ofrece APIs compatibles con OpenAI y Anthropic. Usa nuestro servicio con cualquier SDK, herramienta o app existente de OpenAI o Anthropic simplemente cambiando la base URL. No se requieren cambios de código.

Herramientas CLI y MCP

Smart AIPI ofrece dos paquetes npm para ayudar a los desarrolladores a trabajar con sus cuentas:

Instalar ambos

Instalar por separado

Autenticación

Todas las solicitudes a la API requieren una API key. La misma clave funciona con ambos métodos de autenticación:

Guía de migración

La migración toma menos de un minuto. Nuestra API es 100% compatible con los endpoints de OpenAI y Anthropic.

Desde OpenAI

Desde Anthropic

Finalizaciones de chat

Crea una chat completion para los mensajes y el modelo proporcionados. Este es el endpoint principal para interactuar con modelos de lenguaje.

Parámetros del cuerpo de la solicitud

Roles de mensaje

Ejemplos de código

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

Activa streaming para recibir tokens a medida que se generan mediante Server-Sent Events (SSE). Esto ofrece una mejor experiencia de usuario para respuestas largas.

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

Esfuerzo de razonamiento

Controla la profundidad del razonamiento con el parámetro reasoning_effort para modelos GPT-5.

Modelos compatibles

Niveles de esfuerzo de razonamiento

Modo rápido (procesamiento prioritario)

Usa service_tier: "priority" para procesamiento prioritario con menor latencia. Esto es lo que usa el comando /fast en Codex CLI. No cambia la profundidad del razonamiento: obtienes la misma calidad, más rápido.

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

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

Generación de imágenes

Genera imágenes a partir de prompts de texto usando nuestro endpoint de generación de imágenes.

Parámetros del cuerpo de la solicitud

Modelos disponibles

Ejemplo

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

Edición de imágenes

Edita imágenes existentes usando un prompt de texto. Acepta tanto JSON (string base64) como multipart/form-data (subida de archivo), por lo que los SDK de OpenAI funcionan de inmediato.

Parámetros del cuerpo de la solicitud

Ejemplo

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

WebSockets son una API ampliamente compatible para la transferencia de datos en tiempo real y una excelente opción para conectarte a la Realtime API de Smart AIPI en aplicaciones server-to-server.

En una integración server-to-server, tu sistema backend se conecta por WebSocket directamente a la Realtime API. Usa un Tecla API estándar para autenticar la conexión, ya que el token solo está disponible en tu servidor backend seguro.

Conéctate por WebSocket

A continuación se muestran varios ejemplos de conexión por WebSocket. Además de usar la URL de WebSocket, tendrás que pasar un header de autenticación usando tu 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: ...

Envío y recepción de eventos

Las sesiones se gestionan usando eventos JSON enviados por el cliente y el servidor a través de la conexión WebSocket. Envuelve tu solicitud en un envelope de response.create :

Listar modelos

Recupera una lista de todos los modelos disponibles. Usa este endpoint para descubrir dinámicamente qué modelos están disponibles para tu cuenta.

Formato de respuesta

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

Ejemplo

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"

Modelos disponibles

Anthropic Mensajes API

Compatibilidad completa con Anthropic Messages API. Usa cualquier SDK de Anthropic, Claude Code o app que hable el protocolo de Anthropic; solo cambia la base URL.

Funciones compatibles

Ejemplos de código

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

Mapeo de modelos

Se aceptan nombres de modelo de Claude y se enrutan automáticamente a GPT-5.4 con esfuerzo de razonamiento por niveles. Cada respuesta incluye un x-actual-model header que muestra el modelo backend real.

Claude Code

Usa Claude Code con Smart AIPI como backend. Compatibilidad total con uso de herramientas, streaming y capacidades agentic.

Configuración automática

npx smart-aipi claude

Esto configura ~/.claude/settings.json y ~/.claude.json automáticamente. Si ya tienes Claude Code configurado con una cuenta de Anthropic, te mostrará la configuración manual en lugar de sobrescribirla.

Configuración manual

Agregar a ~/.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"
}

Luego agrega "hasCompletedOnboarding": true a ~/.claude.json para omitir el asistente de configuración.

Qué hace cada configuración

OpenCode

Usa Smart AIPI como tu backend de OpenCode mediante el SDK compatible con OpenAI.

Configuración

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

Códice CLI

Usa Smart AIPI con la herramienta Codex CLI de OpenAI. Hay que configurar tres archivos.

Configuración automática

npx smart-aipi codex

Esto configura automáticamente los tres archivos de abajo. Después de ejecutarlo, agrega model_reasoning_effort a tu configuración (ver paso 2).

Configuración manual

Configura estos tres archivos:

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

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

2. Modelo y razonamiento — ~/.codex/config.toml

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

Niveles de razonamiento válidos: low, medium, high (recomendado), xhigh.

3. Variables de entorno — ~/.zshrc

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

Luego usa Codex normalmente:

codex "fix this bug"

Guía de velocidad de Codex WebSocket

El modo WebSocket suele ser más rápido para flujos de programación agentic con muchas llamadas a herramientas. En lugar de reconectarse repetidamente por HTTP y reenviar envelopes de solicitud completos, Codex mantiene una conexión activa y envía turnos incrementales, lo que reduce la sobrecarga de continuación.

Activa WebSockets en Codex

Usa el feature flag WebSocket v2 en ~/.codex/config.toml: ~/.codex/config.toml:

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

[features]
responses_websockets_v2 = true

Equivalente en CLI:

codex --enable responses_websockets_v2

Las versiones más antiguas pueden usar el flag heredado:

[features]
responses_websockets = true

Comportamiento conocido de Homebrew

En algunas builds distribuidas con Homebrew, los turnos de WebSocket pueden quedarse bloqueados durante tareas de larga duración y luego volver silenciosamente a HTTP. Lo vimos especialmente en bucles complejos de llamadas a herramientas. Reconstruir desde el código open-source con las correcciones de abajo mejoró tanto la estabilidad como la velocidad.

Post-Merge: corrige el bug de WebSocket open-source

Después de fusionar tu rama, usa esta lista de verificación para asegurarte de que la corrección esté en tu binario 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 necesitas aplicar el parche manualmente, verifica que estas correcciones a nivel de código estén presentes:

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

Usa Smart AIPI con Cursor IDE o la extensión Cline para VS Code.

Charlar

Usa Smart AIPI Chat en chat.smartaipi.com. para flujos de trabajo de texto, imagen, video, código, búsqueda y voz.

Funciones

• ✓ Charlar — Conversaciones de texto de uso general con modelos de Smart AIPI.
• ✓ Imágenes — Genera y edita imágenes a partir de prompts.
• ✓ Video — Genera videos a partir de texto o entradas de imagen.
• ✓ Código — Asistencia y edición de código en el navegador.
• ✓ Búsqueda — Usa búsqueda web para obtener respuestas fundamentadas.
• ✓ Voz — Habla con el modelo mediante entrada y respuestas de voz.

Primeros pasos

Facturación: El uso se factura contra tus créditos de Smart AIPI.

Probador de API

Prueba la API directamente desde tu navegador: