AI API

Что такое AI API?

AI API от Aister — это унифицированный интерфейс для доступа к различным языковым моделям. Один API ключ, множество моделей, совместимость с OpenAI SDK и прозрачная тарификация.

Быстрый старт

Получение API ключа

1. Войдите в личный кабинет Aister
2. Перейдите в раздел «AI API»
3. Нажмите «Создать API ключ»
4. Укажите название ключа (например, «Production» или «Development»)
5. Скопируйте ключ — он больше не будет показан

Первый запрос

Отправьте первый запрос к API:

curl https://api.aister.store/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-4-turbo",
    "messages": [
      {"role": "user", "content": "Привет! Как дела?"}
    ]
  }'

Доступные модели

GPT модели (OpenAI)

• gpt-4-turbo — лучшее качество, 128K контекст, $0.01/1K токенов
• gpt-4 — стабильная версия, 8K контекст, $0.03/1K токенов
• gpt-3.5-turbo — быстро и дёшево, 16K контекст, $0.0005/1K токенов

Claude модели (Anthropic)

• claude-3-opus — максимальное качество, 200K контекст, $0.015/1K токенов
• claude-3-sonnet — баланс цены и качества, 200K контекст, $0.003/1K токенов
• claude-3-haiku — быстрые ответы, 200K контекст, $0.00025/1K токенов

Open Source модели

• llama-3-70b — мощная open-source модель, 8K контекст, $0.0008/1K токенов
• mistral-large — европейская альтернатива, 32K контекст, $0.004/1K токенов
• mixtral-8x7b — mixture of experts, 32K контекст, $0.0006/1K токенов

Интеграция

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.aister.store/v1"
)

response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "system", "content": "Ты полезный ассистент."},
        {"role": "user", "content": "Объясни квантовую физику простыми словами"}
    ],
    temperature=0.7,
    max_tokens=500
)

print(response.choices[0].message.content)

Node.js / TypeScript

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.AISTER_API_KEY,
  baseURL: 'https://api.aister.store/v1'
});

async function main() {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      { role: 'system', content: 'Ты полезный ассистент.' },
      { role: 'user', content: 'Напиши функцию для сортировки массива' }
    ],
    temperature: 0.7,
    max_tokens: 1000
  });

  console.log(completion.choices[0].message.content);
}

main();

Go

package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("YOUR_API_KEY")
    config.BaseURL = "https://api.aister.store/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "gpt-4-turbo",
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleUser,
                    Content: "Привет! Как дела?",
                },
            },
        },
    )

    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Println(resp.Choices[0].Message.Content)
}

PHP

<?php
require 'vendor/autoload.php';

use OpenAI\Client;

$client = OpenAI::factory()
    ->withApiKey('YOUR_API_KEY')
    ->withBaseUri('https://api.aister.store/v1')
    ->make();

$response = $client->chat()->create([
    'model' => 'gpt-4-turbo',
    'messages' => [
        ['role' => 'user', 'content' => 'Привет! Как дела?'],
    ],
]);

echo $response->choices[0]->message->content;

Продвинутые возможности

Streaming ответов

Получайте ответы по мере генерации для лучшего UX:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.aister.store/v1"
)

stream = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[{"role": "user", "content": "Напиши длинную историю"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Function Calling

Позвольте модели вызывать ваши функции:

functions = [
    {
        "name": "get_weather",
        "description": "Получить текущую погоду в городе",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Название города"
                }
            },
            "required": ["city"]
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[{"role": "user", "content": "Какая погода в Москве?"}],
    functions=functions,
    function_call="auto"
)

# Если модель решила вызвать функцию
if response.choices[0].message.function_call:
    function_name = response.choices[0].message.function_call.name
    arguments = json.loads(response.choices[0].message.function_call.arguments)
    
    # Вызовите вашу функцию
    result = get_weather(arguments["city"])
    
    # Отправьте результат обратно модели
    second_response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "user", "content": "Какая погода в Москве?"},
            response.choices[0].message,
            {"role": "function", "name": function_name, "content": str(result)}
        ]
    )

Vision (работа с изображениями)

Анализируйте изображения с GPT-4 Vision:

import base64

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

base64_image = encode_image("path/to/image.jpg")

response = client.chat.completions.create(
    model="gpt-4-vision",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Что на этом изображении?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                }
            ]
        }
    ],
    max_tokens=300
)

print(response.choices[0].message.content)

Embeddings

Создавайте векторные представления текста для поиска и кластеризации:

response = client.embeddings.create(
    model="text-embedding-3-large",
    input="Текст для векторизации"
)

embedding = response.data[0].embedding
print(f"Размерность вектора: {len(embedding)}")

# Используйте для семантического поиска
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Сравнение двух текстов
text1_embedding = client.embeddings.create(
    model="text-embedding-3-large",
    input="Кошка сидит на окне"
).data[0].embedding

text2_embedding = client.embeddings.create(
    model="text-embedding-3-large",
    input="Котёнок смотрит в окно"
).data[0].embedding

similarity = cosine_similarity(
    [text1_embedding],
    [text2_embedding]
)[0][0]

print(f"Схожесть: {similarity:.4f}")

Параметры запросов

Основные параметры

• model (обязательный) — название модели
• messages (обязательный) — массив сообщений
• temperature (0-2) — креативность (по умолчанию 1)
• max_tokens — максимальная длина ответа
• top_p (0-1) — nucleus sampling (по умолчанию 1)
• frequency_penalty (-2 до 2) — штраф за повторения
• presence_penalty (-2 до 2) — штраф за упоминание тем
• stop — последовательности для остановки генерации

Оптимизация параметров

• Для кода: temperature=0.2, top_p=0.1 (детерминированность)
• Для креатива: temperature=0.8-1.2 (разнообразие)
• Для анализа: temperature=0.3-0.5 (баланс)
• Для чатов: temperature=0.7, top_p=0.9 (естественность)

Обработка ошибок

Коды ошибок

• 400 Bad Request — неверный формат запроса
• 401 Unauthorized — неверный API ключ
• 429 Too Many Requests — превышен лимит запросов
• 500 Internal Server Error — ошибка сервера
• 503 Service Unavailable — модель временно недоступна

Retry логика

import time
from openai import OpenAI, APIError, RateLimitError

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.aister.store/v1"
)

def chat_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4-turbo",
                messages=messages
            )
            return response
        except RateLimitError:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Rate limit hit. Waiting {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise
        except APIError as e:
            print(f"API error: {e}")
            if attempt < max_retries - 1:
                time.sleep(1)
            else:
                raise

response = chat_with_retry([
    {"role": "user", "content": "Привет!"}
])

Лимиты и квоты

Rate Limits

Лимиты зависят от вашего тарифа:

• Starter: 60 запросов/минуту, 1M токенов/день
• Pro: 300 запросов/минуту, 10M токенов/день
• Enterprise: 1000 запросов/минуту, неограниченные токены

Мониторинг использования

Проверяйте использование через API:

curl https://api.aister.store/v1/usage \
  -H "Authorization: Bearer YOUR_API_KEY"

# Ответ:
{
  "total_tokens": 1234567,
  "total_requests": 5432,
  "period": "2024-03",
  "limit_tokens": 10000000,
  "limit_requests": 300000
}

Безопасность

Защита API ключей

• Никогда не коммитьте ключи в Git
• Используйте переменные окружения
• Ротируйте ключи регулярно
• Создавайте отдельные ключи для разных окружений

Ограничение доступа

Настройте ограничения для API ключей:

• IP whitelist — доступ только с определённых IP
• Лимиты запросов — максимум запросов в минуту
• Доступные модели — ограничение списка моделей
• Срок действия — автоматическое истечение ключа

Content Moderation

Проверяйте контент на нарушения:

response = client.moderations.create(
    input="Текст для проверки"
)

if response.results[0].flagged:
    print("Контент нарушает правила")
    print(response.results[0].categories)

Оптимизация затрат

Выбор модели

• Используйте GPT-3.5 для простых задач (в 60 раз дешевле GPT-4)
• Claude Haiku для быстрых ответов
• Open-source модели для массовой обработки
• GPT-4 только для сложных задач

Оптимизация промптов

• Будьте конкретны — избегайте лишних слов
• Используйте system message вместо повторения инструкций
• Ограничивайте max_tokens для коротких ответов
• Кэшируйте частые запросы

Кэширование

import hashlib
import json
from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_completion(prompt_hash):
    # Реальный запрос к API
    response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

def get_completion(prompt):
    # Создаём хеш промпта
    prompt_hash = hashlib.md5(prompt.encode()).hexdigest()
    return cached_completion(prompt_hash)

Примеры использования

Чат-бот для Telegram

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.aister.store/v1"
)

async def handle_message(update: Update, context):
    user_message = update.message.text
    
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "Ты дружелюбный помощник."},
            {"role": "user", "content": user_message}
        ]
    )
    
    await update.message.reply_text(response.choices[0].message.content)

app = Application.builder().token("YOUR_TELEGRAM_TOKEN").build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
app.run_polling()

Анализ отзывов

def analyze_review(review_text):
    response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {
                "role": "system",
                "content": "Проанализируй отзыв и верни JSON с полями: sentiment (positive/negative/neutral), rating (1-5), key_points (массив), issues (массив)"
            },
            {"role": "user", "content": review_text}
        ],
        response_format={"type": "json_object"}
    )
    
    return json.loads(response.choices[0].message.content)

review = "Отличный продукт, но доставка задержалась на 3 дня"
analysis = analyze_review(review)
print(analysis)

Генерация кода

def generate_code(description, language="python"):
    response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {
                "role": "system",
                "content": f"Ты эксперт по {language}. Пиши чистый, документированный код с обработкой ошибок."
            },
            {
                "role": "user",
                "content": f"Напиши {language} код: {description}"
            }
        ],
        temperature=0.2
    )
    
    return response.choices[0].message.content

code = generate_code("функция для валидации email адреса")
print(code)

Миграция с OpenAI

Изменения в коде

Для миграции с OpenAI API нужно изменить только base_url:

# Было:
client = OpenAI(api_key="sk-...")

# Стало:
client = OpenAI(
    api_key="YOUR_AISTER_KEY",
    base_url="https://api.aister.store/v1"
)

Преимущества миграции

• Экономия до 40% на стоимости токенов
• Данные остаются в России (соответствие 152-ФЗ)
• Более низкая латентность для российских пользователей
• Поддержка на русском языке
• Гибкая тарификация