XUSS AI API

XUSS hosting platformasi ustida ishlaydigan, OpenAI bilan mos ishlab chiqarish (production) API'si. Istalgan OpenAI SDK, muharrir yoki chat klientini XUSS'ga ulang — hech qanday vendorga bog'lanib qolmaysiz: bitta kalit va XUSS balansingizdan foydalanganingizcha to'lov.

• Asosiy URL: https://xuss.us/v1
• Autentifikatsiya: Authorization: Bearer xsk-… (panelda kalit yarating)
• Panel: https://xuss.us/panel/api
• Format: OpenAI Chat Completions (striming, vositalar, rasmlarni ko'rish, JSON rejimi)

Tez boshlash

1. API kalitini yarating. Panelda API → API kalitlari → Kalit yaratish bo'limiga o'ting. Kalitni nusxalab oling — u faqat bir marta ko'rsatiladi. Kalitlar xsk- bilan boshlanadi.

2. API'ga murojaat qiling. Istalgan tilda chaqiruv yozing — yorliqni tanlang:

curl https://xuss.us/v1/chat/completions \
  -H "Authorization: Bearer xsk-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "xuss/kitsune",
    "messages": [{"role": "user", "content": "Salom!"}]
  }'

from openai import OpenAI

client = OpenAI(base_url="https://xuss.us/v1", api_key="xsk-YOUR_KEY")

r = client.chat.completions.create(
    model="xuss/kitsune",
    messages=[{"role": "user", "content": "Salom!"}],
)
print(r.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://xuss.us/v1", apiKey: "xsk-YOUR_KEY" });

const r = await client.chat.completions.create({
  model: "xuss/kitsune",
  messages: [{ role: "user", content: "Salom!" }],
});
console.log(r.choices[0].message.content);

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
)

func main() {
	body := []byte(`{"model":"xuss/kitsune","messages":[{"role":"user","content":"Salom!"}]}`)
	req, _ := http.NewRequest("POST", "https://xuss.us/v1/chat/completions", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer xsk-YOUR_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

<?php
$ch = curl_init('https://xuss.us/v1/chat/completions');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer xsk-YOUR_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'model' => 'xuss/kitsune',
        'messages' => [['role' => 'user', 'content' => 'Salom!']],
    ]),
]);
$res = json_decode(curl_exec($ch), true);
echo $res['choices'][0]['message']['content'], PHP_EOL;

Shu bilan tayyor — XUSS balansingizdan har bir token uchun to'lov yechiladi, hech qanday obuna shart emas.

Autentifikatsiya

Har bir so'rovda bearer token bo'lishi shart:

Authorization: Bearer xsk-YOUR_KEY
Content-Type: application/json

Kalitlar Panel → API bo'limida yaratiladi va bekor qilinadi. Qoidalar:

• Kalit xsk- va undan keyin keladigan uzun tasodifiy satrdan iborat. Ko'rsatish uchun faqat boshlang'ich belgilar saqlanadi; to'liq qiymat yaratilganda bir marta ko'rsatiladi.
• Bitta hisobda 10 tagacha faol kalit bo'lishi mumkin.
• Har bir kalitda ixtiyoriy amal qilish muddati va ixtiyoriy sarflash chegarasi (USD) bo'lishi mumkin. Kalit muddati tugasa yoki chegaraga yetsa, u bilan yuborilgan so'rovlar yangi kalit yaratmaguningizcha yoki chegarani oshirmaguningizcha 401 (key_expired) yoki 402 (key_spend_limit_reached) xatosi bilan rad etiladi.
• Panelda kalit yaratish Cloudflare Turnstile (kaptcha) bilan himoyalangan, shuning uchun kalitlarni skriptlar orqali yaratib bo'lmaydi.
• Kalitni bekor qilish darhol kuchga kiradi.
• Kalitlar hisobingizning AI API'ga kirish huquqini meros oladi. Agar hisobingiz uchun API yoqilmagan bo'lsa, so'rovlar 403 qaytaradi.

Kalitni hech qachon klient tomonidagi kodda yoki ochiq repozitoriylarda oshkor qilmang. Kalit oshkor bo'lsa, uni panelda bekor qilib, yangisini yarating.

Endpointlar

Barchasi Authorization: Bearer xsk-… sarlavhasini qabul qiladi.

Modellar

GET /v1/models API'da taqdim etilgan modellarni kontekst oynasi, rasmlarni ko'rish qo'llab-quvvatlashi va har bir token narxi bilan qaytaradi:

{
  "object": "list",
  "data": [
    {
      "id": "xuss/kitsune",
      "object": "model",
      "owned_by": "xuss",
      "context_window": 1048576,
      "vision": true,
      "pricing": {
        "prompt": 0.00000029,
        "completion": 0.00000129,
        "input_cache_read": 0.0000000099
      }
    }
  ]
}

Narxlar har bir token uchun USDda ko'rsatilgan. Paneldagi 1 million token uchun narxni olish uchun 1 000 000 ga ko'paytiring.

Modelni yo'naltirish. Bitta model identifikatori ortida XUSS xizmat tez va uzluksiz bo'lishi uchun so'rovlarni turli quvvatlarga yo'naltirishi mumkin. Bu sizga sezilmaydi: so'ralgan model har doim javobda qaytariladigan modeldir va model o'z nomini biladi. /v1/modelsda ko'rsatilgan narxlar — sizdan yechiladigan narxlardir.

Chat completions

POST /v1/chat/completions

So'rov tanasi (body)

messages OpenAI sxemasiga muvofiq bo'ladi (system, user, assistant, tool rollari; multimodal kontent massivlari).

Javob

{
  "id": "chatcmpl-3f9c1a...",
  "object": "chat.completion",
  "created": 1791000000,
  "model": "xuss/kitsune",
  "choices": [
    {
      "index": 0,
      "message": {"role": "assistant", "content": "Salom! Qanday yordam bera olaman?"},
      "finish_reason": "stop",
      "logprobs": null
    }
  ],
  "usage": {"prompt_tokens": 12, "completion_tokens": 7, "total_tokens": 19},
  "system_fingerprint": "xuss"
}

finish_reason — stop, length yoki tool_calls.

Xabarlar (messages)

Standart OpenAI xabarlar massivi. Eng oddiy bir martalik so'rov:

{"model": "xuss/kitsune", "messages": [{"role": "user", "content": "Salom"}]}

Ko'p bosqichli suhbat uchun har safar to'liq tarixni yuboring:

{
  "model": "xuss/kitsune",
  "messages": [
    {"role": "system", "content": "Sen qisqa va aniq javob beradigan yordamchisan."},
    {"role": "user", "content": "XUSS nima?"},
    {"role": "assistant", "content": "XUSS — bu hosting platformasi."},
    {"role": "user", "content": "Uning AI API'si bormi?"}
  ]
}

Striming

Server-Sent Events olish uchun "stream": true qiymatini bering. Har bir satr data: {json} ko'rinishida bo'ladi; oqim data: [DONE] bilan tugaydi.

Bo'laklar (chunk) quyidagicha ko'rinadi:

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","created":…,"model":"xuss/kitsune","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}],"system_fingerprint":"xuss"}

data: {"id":"chatcmpl-…","choices":[{"index":0,"delta":{"content":"Serverlar "},"finish_reason":null}]}

data: {"id":"chatcmpl-…","choices":[{"index":0,"delta":{"content":"jimjit "},"finish_reason":null}]}

data: {"id":"chatcmpl-…","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":9,"total_tokens":23}}

data: [DONE]

Oqimni istalgan tilda o'qing:

curl -N https://xuss.us/v1/chat/completions \
  -H "Authorization: Bearer xsk-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"xuss/kitsune","stream":true,
       "messages":[{"role":"user","content":"Serverlar haqida xayku yoz"}]}'

stream = client.chat.completions.create(
    model="xuss/kitsune",
    messages=[{"role": "user", "content": "Serverlar haqida xayku yoz"}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content if chunk.choices else None
    if delta:
        print(delta, end="", flush=True)

const stream = await client.chat.completions.create({
  model: "xuss/kitsune",
  messages: [{ role: "user", content: "Serverlar haqida xayku yoz" }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || "");
}

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"net/http"
	"strings"
)

func main() {
	body := []byte(`{"model":"xuss/kitsune","stream":true,"messages":[{"role":"user","content":"Serverlar haqida xayku yoz"}]}`)
	req, _ := http.NewRequest("POST", "https://xuss.us/v1/chat/completions", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer xsk-YOUR_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()

	sc := bufio.NewScanner(res.Body)
	for sc.Scan() {
		line := sc.Text()
		if !strings.HasPrefix(line, "data: ") || strings.HasSuffix(line, "[DONE]") {
			continue
		}
		fmt.Println(line[6:]) // parse JSON, read choices[0].delta.content
	}
}

<?php
$ch = curl_init('https://xuss.us/v1/chat/completions');
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer xsk-YOUR_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'model' => 'xuss/kitsune',
        'stream' => true,
        'messages' => [['role' => 'user', 'content' => 'Serverlar haqida xayku yoz']],
    ]),
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) {
        foreach (explode("\n", $chunk) as $line) {
            if (str_starts_with($line, 'data: ') && !str_contains($line, '[DONE]')) {
                $j = json_decode(substr($line, 6), true);
                echo $j['choices'][0]['delta']['content'] ?? '';
            }
        }
        return strlen($chunk);
    },
]);
curl_exec($ch);

Model mulohaza yuritishni (reasoning) qo'llab-quvvatlasa, striming bo'laklarida delta ichida qo'shimcha reasoning_content maydoni bo'lishi mumkin. Standart SDKlar uni e'tiborsiz qoldiradi va uni javob sifatida qayta ishlashingiz shart emas.

Tizim ko'rsatmalari (system) va identifikatsiya

Sizning system xabarlaringiz hisobga olinadi. Model o'zining ko'rsatiladigan nomini ham biladi va "sen qaysi modelsan?" deb so'ralganda faqat shu nom bilan javob beradi — u hech qachon yuqori provayder yoki yo'nalishni oshkor qilmaydi.

{
  "model": "xuss/kitsune",
  "messages": [
    {"role": "system", "content": "Sen qisqa DevOps yordamchisisan. Nuqtalar bilan javob ber."},
    {"role": "user", "content": "systemd xizmatini qanday qayta ishga tushiraman?"}
  ]
}

Rasmlarni ko'rish (vision)

Rasmlarni OpenAI image_url kontent qismlari sifatida yuboring (data URL yoki ochiq http(s) URL). /v1/modelsda "vision": true bo'lgan modellargina rasmlarni qabul qiladi; rasmlarni ko'rish qo'llab-quvvatlanmaydigan modelga rasm yuborsangiz, matnli eslatma qaytariladi va model faqat matn asosida javob beradi.

r = client.chat.completions.create(
    model="xuss/kitsune",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Bu rasmda nima ko'rinib turibdi?"},
            {"type": "image_url", "image_url": {"url": "data:image/png;base64,iVBORw0KGgo..."}},
        ],
    }],
)

Cheklovlar: 8 tagacha rasm qismi, har biri ~6 MBgacha; rasmlar matn byudjetiga hisoblanmaydi.

Funksiyalarni chaqirish

OpenAI uslubidagi tools yuboring. Model biror funksiyani chaqirishga qaror qilsa, finish_reason tool_calls bo'ladi va xabar tool_callsni o'z ichiga oladi.

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

r = client.chat.completions.create(
    model="xuss/kitsune",
    messages=[{"role": "user", "content": "Toshkentda ob-havo qanday?"}],
    tools=tools,
)

call = r.choices[0].message.tool_calls[0]
print(call.function.name, call.function.arguments)

So'ngra natijani tool xabari sifatida qaytaring:

messages = [
    {"role": "user", "content": "Toshkentda ob-havo qanday?"},
    r.choices[0].message,
    {"role": "tool", "tool_call_id": call.id, "content": '{"temp_c": 24, "sky": "clear"}'},
]
final = client.chat.completions.create(model="xuss/kitsune", messages=messages)

Server vositalari (veb + ko'nikmalar)

Har bir so'rovda alohida yoqiladi. "xuss_tools": true (barchasi) yoki kerakli vositalar massivini qo'shing. Shundan so'ng XUSS bu vositalarni serverda siz uchun ishga tushiradi — model ularni chaqiradi, server bajaradi va davom etadi, natijada yakuniy javobni o'sha javobning o'zida olasiz. Klient tomonida hech qanday tsikl kerak emas.

r = client.chat.completions.create(
    model="xuss/kitsune",
    xuss_tools=True,                       # yoki ["web_search", "read_skill"]
    messages=[{"role": "user",
               "content": "Internetdan Python'ning eng so'nggi versiyasini topib, qisqacha bayon qiling."}],
)
print(r.choices[0].message.content)

{
  "model": "xuss/kitsune",
  "xuss_tools": true,
  "messages": [{"role": "user", "content": "https://example.com ni ochib, sahifa sarlavhasini ayting."}]
}

Bular faqat o'qish uchun: fayllar, ma'lumotlar bazalari, hostinglar yoki hisobingizga kirish imkoni yo'q. Biror narsani o'zgartiradigan vositalar (fayllarni boshqarish, DNS, ma'lumotlar bazalari va hokazo) sizning qo'lingizda qoladi va ataylab ochilmagan.

• Strimingsiz: server vosita tsiklini (6 bosqichgacha) ishga tushiradi va yakuniy javobni qaytaradi; usage (va billing) har bir bosqichni qamrab oladi.
• Striming bilan ("stream": true): vositalar serverda bajariladi, so'ng yakuniy javob odatdagidek SSE sifatida uzatiladi.
• Agar o'zingizning toolsingizni ham yuborsangiz, model ikkalasini ham chaqirishi mumkin — XUSS o'z vositalarini bajaradi, sizning vosita chaquruvingizni esa bajarish uchun tool_calls orqali sizga qaytaradi (standart xatti-harakat).
• Ularni ish vaqtida bilib oling: GET /v1/tools (ta'riflar) va GET /v1/skills (quyidagi ro'yxat).

Mavjud ko'nikmalar

read_skill ulardan istalganining to'liq ma'lumotnoma hujjatini kontekstga yuklaydi — modelga qaysi biri kerakligini aytish kifoya (masalan, "product-design ko'nikmasidan foydalan").

Tuzilgan chiqish (JSON rejimi)

response_formatni {"type":"json_object"} qiymatiga o'rnating va modeldan JSON chiqarishni so'rang. Javobning content maydoni JSON satridan iborat.

r = client.chat.completions.create(
    model="xuss/kitsune",
    response_format={"type": "json_object"},
    messages=[{"role": "user",
               "content": "a va b kalitlari bo'lgan JSON qaytaring, a=1, b=2"}],
)
import json
print(json.loads(r.choices[0].message.content))  # {'a': 1, 'b': 2}

Har doim himoyalangan tarzda tahlil qiling va so'rovda (promptda) kerakli aniq shaklni tavsiflab bering.

Billing va token hisobi

• To'lovlar XUSS balansingizdan yechiladi (panelda to'ldirishingiz mumkin).
• Har bir token uchun modelning API narxida hisoblanadi: kirish (keshda yo'q), keshga tushgan (qo'llab-quvvatlansa arzonroq) va chiqish.
• Har bir so'rovning usage maydoni prompt_tokens, completion_tokens va total_tokensni ko'rsatadi.
• Paneldagi API sahifasi sarf-xarajat, so'rovlar, tokenlar, model va kalit bo'yicha taqsimotni hamda so'nggi chaqiruvlar jurnalini tanlanadigan davrlar (bugun, 7/30/90 kun, joriy/o'tgan oy, butun davr) bilan ko'rsatadi.
• Balans yetarli bo'lmasa, so'rovlar 402 bilan rad etiladi.

Xarajat formulasi (har bir so'rov uchun):

cost = cache_miss_tokens × price_in
     + cache_hit_tokens  × price_cache
     + completion_tokens × price_out

(Narxlar har bir token uchun; 1 million uchun narxni olish uchun 1 000 000 ga bo'ling.)

So'rovlar chastotasi chegaralari va kvotalar

Chegaradan oshsangiz 429 qaytariladi, Retry-After mantiqiga muvofiq (biroz kutib, qayta urinib ko'ring). So'rov tanasi hajmi 25 MB bilan cheklangan.

Xatoliklar

Xatoliklar OpenAI xatolik formatiga muvofiq beriladi:

{
  "error": {
    "message": "Model 'xuss/foo' not found",
    "type": "invalid_request_error",
    "param": "model",
    "code": "model_not_found"
  }
}

param xatolik so'rovning muayyan maydoniga tegishli bo'lganda o'rnatiladi. Standart SDKlar error.message (va error.code) maydonlarini to'g'ridan-to'g'ri o'qiydi.

Oqim allaqachon boshlangan bo'lsa, vaqtinchalik nosozliklar "The model is temporarily unavailable…" bilan boshlanadigan oddiy yordamchi xabari sifatida ham yetkaziladi.

OpenAI bilan mos vositalar bilan foydalanish

Maxsus OpenAI asosiy URL manzilini qo'llab-quvvatlaydigan har qanday klient ishlaydi. Quyidagilarni o'rnating:

• Asosiy URL: https://xuss.us/v1
• API kaliti: sizning xsk-… kalitingiz
• Model: masalan, xuss/kitsune

Misollar:

# open-webui / LibreChat / Cursor / Cline / Continue / LangChain:
#   set the OpenAI base URL to https://xuss.us/v1 and paste your key

Muhit o'zgaruvchilari uslubi (ko'plab vositalar bularni hisobga oladi):

export OPENAI_BASE_URL="https://xuss.us/v1"
export OPENAI_API_KEY="xsk-YOUR_KEY"

LangChain (Python):

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="xuss/kitsune", base_url="https://xuss.us/v1",
                 api_key="xsk-YOUR_KEY")
print(llm.invoke("Salom").content)

Qo'shimcha parametrlar

Quyidagilar qabul qilinadi va qo'llab-quvvatlansa modelga uzatiladi: top_p, stop, seed, presence_penalty, frequency_penalty, logit_bias, user, n, parallel_tool_calls, tool_choice.

Ko'p so'raladigan savollar

Alohida obuna kerakmi? Yo'q. XUSS balansingizdan har bir token uchun to'laysiz.

Qaysi model identifikatorlaridan foydalanaman? Aynan GET /v1/modelsda ko'rsatilganlaridan (masalan, xuss/kitsune). "Kitsune" kabi ko'rsatiladigan nomlar panelda ko'rsatiladi.

Rasm yubora olamanmi? Ha, "vision": true deb belgilangan modellarga.

Ma'lumotlarim o'qitish uchun ishlatiladimi? Yo'q — so'rovlar javobingizni shakllantirish uchun modelga uzatiladi va o'qitish uchun ishlatilmaydi.

Provayder sekin ishlasa yoki ishlamay qolsa nima bo'ladi? So'rov muqobil quvvatlarda ko'rinmas tarzda qayta uriniladi; model identifikatori va narx o'zgarishsiz qoladi.

Kalitni qanday almashtiraman? Yangi kalit yarating, ilovalaringizni unga o'tkazing, so'ng eski kalitni panelda bekor qiling.

Qo'llab-quvvatlash

• Panel: https://xuss.us/panel/api
• Panel boshqaruv panelidan ticket va Telegram orqali qo'llab-quvvatlash
• Email: support@xuss.us