API для AI/ML: интеграция с OpenAI, Anthropic, Hugging Face

# Python
pip install openai

# Node.js
npm install openai

# Получение API ключа
# 1. Зарегистрируйтесь на platform.openai.com
# 2. Перейдите в API Keys
# 3. Создайте новый ключ
# 4. Сохраните ключ в переменных окружения

# openai_example.py
from openai import OpenAI
import os

# Инициализация клиента
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

# Простой запрос
def chat_completion(prompt):
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
        max_tokens=500
    )
    
    return response.choices[0].message.content

# Использование
result = chat_completion("Объясни, что такое API простыми словами")
print(result)

# Streaming запрос
def chat_completion_stream(prompt):
    stream = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "user", "content": prompt}
        ],
        stream=True
    )
    
    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            print(chunk.choices[0].delta.content, end='')

# Embeddings
def get_embeddings(text):
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

// openai_example.js
const OpenAI = require('openai');

// Инициализация клиента
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

// Простой запрос
async function chatCompletion(prompt) {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      { role: 'system', content: 'You are a helpful assistant.' },
      { role: 'user', content: prompt }
    ],
    temperature: 0.7,
    max_tokens: 500
  });
  
  return completion.choices[0].message.content;
}

// Использование
chatCompletion('Объясни, что такое API простыми словами')
  .then(result => console.log(result))
  .catch(error => console.error('Error:', error));

// Streaming запрос
async function chatCompletionStream(prompt) {
  const stream = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: prompt }],
    stream: true
  });
  
  for await (const chunk of stream) {
    if (chunk.choices[0]?.delta?.content) {
      process.stdout.write(chunk.choices[0].delta.content);
    }
  }
}

// Embeddings
async function getEmbeddings(text) {
  const response = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: text
  });
  
  return response.data[0].embedding;
}

# anthropic_example.py
import anthropic
import os

# Инициализация клиента
client = anthropic.Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))

# Простой запрос
def claude_completion(prompt):
    message = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=1024,
        system="You are a helpful assistant.",
        messages=[
            {"role": "user", "content": prompt}
        ]
    )
    
    return message.content[0].text

# Использование
result = claude_completion("Объясни концепцию машинного обучения")
print(result)

# Streaming запрос
def claude_completion_stream(prompt):
    with client.messages.stream(
        model="claude-3-opus-20240229",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": prompt}
        ]
    ) as stream:
        for text in stream.text_stream:
            print(text, end='', flush=True)

// anthropic_example.js
const Anthropic = require('@anthropic-ai/sdk');

// Инициализация клиента
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY
});

// Простой запрос
async function claudeCompletion(prompt) {
  const message = await anthropic.messages.create({
    model: 'claude-3-opus-20240229',
    max_tokens: 1024,
    system: 'You are a helpful assistant.',
    messages: [
      { role: 'user', content: prompt }
    ]
  });
  
  return message.content[0].text;
}

// Использование
claudeCompletion('Объясни концепцию машинного обучения')
  .then(result => console.log(result))
  .catch(error => console.error('Error:', error));

// Streaming запрос
async function claudeCompletionStream(prompt) {
  const stream = await anthropic.messages.stream({
    model: 'claude-3-opus-20240229',
    max_tokens: 1024,
    messages: [
      { role: 'user', content: prompt }
    ]
  });
  
  for await (const chunk of stream) {
    if (chunk.type === 'content_block_delta') {
      process.stdout.write(chunk.delta.text);
    }
  }
}

# huggingface_example.py
import requests
import os

API_URL = "https://api-inference.huggingface.co/models"
headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_API_KEY')}"}

# Текстовая генерация
def text_generation(prompt, model="gpt2"):
    response = requests.post(
        f"{API_URL}/{model}",
        headers=headers,
        json={"inputs": prompt}
    )
    return response.json()

# Анализ тональности
def sentiment_analysis(text, model="cardiffnlp/twitter-roberta-base-sentiment-latest"):
    response = requests.post(
        f"{API_URL}/{model}",
        headers=headers,
        json={"inputs": text}
    )
    return response.json()

# Перевод
def translation(text, model="Helsinki-NLP/opus-mt-ru-en"):
    response = requests.post(
        f"{API_URL}/{model}",
        headers=headers,
        json={"inputs": text}
    )
    return response.json()

# Использование
result = sentiment_analysis("I love this product!")
print(result)

// huggingface_example.js
const axios = require('axios');

const API_URL = 'https://api-inference.huggingface.co/models';
const headers = {
  'Authorization': `Bearer ${process.env.HUGGINGFACE_API_KEY}`
};

// Текстовая генерация
async function textGeneration(prompt, model = 'gpt2') {
  const response = await axios.post(
    `${API_URL}/${model}`,
    { inputs: prompt },
    { headers }
  );
  return response.data;
}

// Анализ тональности
async function sentimentAnalysis(text, model = 'cardiffnlp/twitter-roberta-base-sentiment-latest') {
  const response = await axios.post(
    `${API_URL}/${model}`,
    { inputs: text },
    { headers }
  );
  return response.data;
}

// Использование
sentimentAnalysis('I love this product!')
  .then(result => console.log(result))
  .catch(error => console.error('Error:', error));

# error_handling.py
import time
import openai
from openai import OpenAI

client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def chat_completion_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=500
            )
            return response.choices[0].message.content
            
        except openai.RateLimitError:
            # Rate limit - ждем и retry
            wait_time = 2 ** attempt  # Exponential backoff
            print(f"Rate limit hit. Waiting {wait_time} seconds...")
            time.sleep(wait_time)
            
        except openai.APIError as e:
            # API ошибка - проверяем, можно ли retry
            if e.status_code == 429 or e.status_code >= 500:
                wait_time = 2 ** attempt
                print(f"API error: {e}. Retrying in {wait_time} seconds...")
                time.sleep(wait_time)
            else:
                # Постоянная ошибка - не retry
                raise
                
        except Exception as e:
            # Неожиданная ошибка
            print(f"Unexpected error: {e}")
            raise
    
    raise Exception("Max retries exceeded")

# Использование
try:
    result = chat_completion_with_retry("Hello, world!")
    print(result)
except Exception as e:
    print(f"Failed to get completion: {e}")

# rate_limiting.py
import time
from collections import deque
from openai import OpenAI

class RateLimiter:
    def __init__(self, max_requests=60, time_window=60):
        self.max_requests = max_requests
        self.time_window = time_window
        self.requests = deque()
    
    def wait_if_needed(self):
        now = time.time()
        
        # Удаляем старые запросы
        while self.requests and self.requests[0] < now - self.time_window:
            self.requests.popleft()
        
        # Проверяем лимит
        if len(self.requests) >= self.max_requests:
            sleep_time = self.time_window - (now - self.requests[0])
            if sleep_time > 0:
                print(f"Rate limit reached. Waiting {sleep_time:.2f} seconds...")
                time.sleep(sleep_time)
        
        # Добавляем текущий запрос
        self.requests.append(time.time())

# Использование
rate_limiter = RateLimiter(max_requests=60, time_window=60)
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def chat_with_rate_limit(prompt):
    rate_limiter.wait_if_needed()
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=500
    )
    
    return response.choices[0].message.content