Создание AI API на FastAPI с OpenAI

Создайте AI-powered API на FastAPI с интеграцией OpenAI через AITUNNEL.

## Установка

```bash
pip install fastapi uvicorn openai
```

## Базовый пример

```python
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from openai import OpenAI
import asyncio

app = FastAPI()

client = OpenAI(
    api_key="sk-aitunnel-xxx",
    base_url="https://api.aitunnel.ru/v1/"
)

class ChatRequest(BaseModel):
    message: str
    model: str = "gpt-5.2"

@app.post("/chat")
async def chat(request: ChatRequest):
    response = client.chat.completions.create(
        model=request.model,
        messages=[{"role": "user", "content": request.message}]
    )
    return {"response": response.choices[0].message.content}

@app.post("/chat/stream")
async def chat_stream(request: ChatRequest):
    async def generate():
        stream = client.chat.completions.create(
            model=request.model,
            messages=[{"role": "user", "content": request.message}],
            stream=True
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"
    
    return StreamingResponse(generate(), media_type="text/event-stream")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

## Асинхронный клиент

```python
from openai import AsyncOpenAI

async_client = AsyncOpenAI(
    api_key="sk-aitunnel-xxx",
    base_url="https://api.aitunnel.ru/v1/"
)

@app.post("/chat/async")
async def chat_async(request: ChatRequest):
    response = await async_client.chat.completions.create(
        model=request.model,
        messages=[{"role": "user", "content": request.message}]
    )
    return {"response": response.choices[0].message.content}
```

Интеграция FastAPI с OpenAI API. Создание AI-powered backend на Python. GPT-5 в России. Примеры кода.

FastAPI + OpenAI интеграция | Python API | AITUNNEL

FastAPI + OpenAI интеграция

Добавление AI в Django проект

Интегрируйте ChatGPT в ваш Django проект для AI-функций.

## Установка

```bash
pip install openai django
```

## Настройка

```python
# settings.py
AITUNNEL_API_KEY = "sk-aitunnel-xxx"
AITUNNEL_BASE_URL = "https://api.aitunnel.ru/v1/"
```

## Сервис для работы с AI

```python
# services/ai_service.py
from django.conf import settings
from openai import OpenAI

class AIService:
    def __init__(self):
        self.client = OpenAI(
            api_key=settings.AITUNNEL_API_KEY,
            base_url=settings.AITUNNEL_BASE_URL
        )
    
    def chat(self, message: str, model: str = "gpt-5.2") -> str:
        response = self.client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": message}]
        )
        return response.choices[0].message.content
    
    def summarize(self, text: str) -> str:
        return self.chat(f"Кратко изложи: {text}")
    
    def translate(self, text: str, target_lang: str = "ru") -> str:
        return self.chat(f"Переведи на {target_lang}: {text}")

ai_service = AIService()
```

## Использование во views

```python
# views.py
from django.http import JsonResponse
from django.views.decorators.http import require_POST
from .services.ai_service import ai_service
import json

@require_POST
def chat_view(request):
    data = json.loads(request.body)
    message = data.get("message")
    
    response = ai_service.chat(message)
    return JsonResponse({"response": response})

@require_POST
def summarize_view(request):
    data = json.loads(request.body)
    text = data.get("text")
    
    summary = ai_service.summarize(text)
    return JsonResponse({"summary": summary})
```

## Django REST Framework

```python
# serializers.py
from rest_framework import serializers

class ChatSerializer(serializers.Serializer):
    message = serializers.CharField()
    model = serializers.CharField(default="gpt-5.2")

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response

class ChatAPIView(APIView):
    def post(self, request):
        serializer = ChatSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        
        response = ai_service.chat(
            serializer.validated_data["message"],
            serializer.validated_data["model"]
        )
        return Response({"response": response})
```

Интеграция Django с ChatGPT API. AI функции в Django проекте. GPT-5 в России. Примеры кода.

Django + ChatGPT интеграция | Python | AITUNNEL

Django + ChatGPT интеграция

Создание чат-интерфейса с AI на React

Создайте красивый чат-интерфейс на React с интеграцией GPT через AITUNNEL.

## Установка

```bash
npm install openai
```

## Компонент чата

```typescript
// ChatComponent.tsx
import { useState } from 'react';
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-aitunnel-xxx',
  baseURL: 'https://api.aitunnel.ru/v1/',
  dangerouslyAllowBrowser: true // Только для демо!
});

interface Message {
  role: 'user' | 'assistant';
  content: string;
}

export function ChatComponent() {
  const [messages, setMessages] = useState<Message[]>([]);
  const [input, setInput] = useState('');
  const [loading, setLoading] = useState(false);

  const sendMessage = async () => {
    if (!input.trim()) return;

    const userMessage: Message = { role: 'user', content: input };
    setMessages(prev => [...prev, userMessage]);
    setInput('');
    setLoading(true);

    try {
      const response = await client.chat.completions.create({
        model: 'gpt-5.2',
        messages: [...messages, userMessage]
      });

      const assistantMessage: Message = {
        role: 'assistant',
        content: response.choices[0].message.content || ''
      };
      setMessages(prev => [...prev, assistantMessage]);
    } catch (error) {
      console.error(error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="chat-container">
      <div className="messages">
        {messages.map((msg, i) => (
          <div key={i} className={`message ${msg.role}`}>
            {msg.content}
          </div>
        ))}
        {loading && <div className="loading">Думаю...</div>}
      </div>
      <div className="input-area">
        <input
          value={input}
          onChange={e => setInput(e.target.value)}
          onKeyPress={e => e.key === 'Enter' && sendMessage()}
          placeholder="Введите сообщение..."
        />
        <button onClick={sendMessage} disabled={loading}>
          Отправить
        </button>
      </div>
    </div>
  );
}
```

## Streaming версия

```typescript
const sendMessageStreaming = async () => {
  // ... setup ...

  const stream = await client.chat.completions.create({
    model: 'gpt-5.2',
    messages: [...messages, userMessage],
    stream: true
  });

  let content = '';
  for await (const chunk of stream) {
    content += chunk.choices[0]?.delta?.content || '';
    setMessages(prev => {
      const updated = [...prev];
      updated[updated.length - 1] = { role: 'assistant', content };
      return updated;
    });
  }
};
```

## Важно: Backend API

Для production используйте backend API:

```typescript
// Не храните ключ на фронтенде!
const response = await fetch('/api/chat', {
  method: 'POST',
  body: JSON.stringify({ messages })
});
```

Создание чат-интерфейса на React с GPT. Streaming, история сообщений. GPT-5 API в России.

React чат с GPT | ChatGPT UI | AITUNNEL

React чат с GPT

Создание умного Telegram бота с GPT

Создайте Telegram бота с AI на Python, который запоминает контекст разговора.

## Установка

```bash
pip install python-telegram-bot openai
```

## Полный код бота

```python
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
from openai import OpenAI
from collections import defaultdict

# Настройка клиентов
client = OpenAI(
    api_key="sk-aitunnel-xxx",
    base_url="https://api.aitunnel.ru/v1/"
)

# Хранилище истории диалогов
conversations = defaultdict(list)
MAX_HISTORY = 10

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "Привет! Я AI-бот на базе GPT-5. Задайте мне любой вопрос!"
    )

async def clear(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    conversations[user_id] = []
    await update.message.reply_text("История очищена!")

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    user_message = update.message.text
    
    # Добавляем сообщение в историю
    conversations[user_id].append({
        "role": "user",
        "content": user_message
    })
    
    # Ограничиваем историю
    if len(conversations[user_id]) > MAX_HISTORY * 2:
        conversations[user_id] = conversations[user_id][-MAX_HISTORY * 2:]
    
    # Отправляем "печатает..."
    await update.message.chat.send_action("typing")
    
    try:
        response = client.chat.completions.create(
            model="gpt-5.2",
            messages=[
                {"role": "system", "content": "Ты полезный ассистент. Отвечай кратко и по делу."},
                *conversations[user_id]
            ]
        )
        
        assistant_message = response.choices[0].message.content
        
        # Сохраняем ответ в историю
        conversations[user_id].append({
            "role": "assistant",
            "content": assistant_message
        })
        
        await update.message.reply_text(assistant_message)
        
    except Exception as e:
        await update.message.reply_text(f"Ошибка: {str(e)}")

def main():
    app = Application.builder().token("YOUR_BOT_TOKEN").build()
    
    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("clear", clear))
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    
    print("Бот запущен!")
    app.run_polling()

if __name__ == "__main__":
    main()
```

## Дополнительные функции

### Генерация изображений

```python
@app.on_message(filters.command("image"))
async def generate_image(update: Update, context: ContextTypes.DEFAULT_TYPE):
    prompt = " ".join(context.args)
    
    response = client.images.generate(
        model="gpt-image-1.5",
        prompt=prompt,
        size="1024x1024"
    )
    
    await update.message.reply_photo(response.data[0].url)
```

Создание Telegram бота с ChatGPT на Python. История диалогов, команды. GPT-5 API в России.

Telegram бот на GPT Python | ChatGPT бот | AITUNNEL

Telegram бот на GPT (Python)

Интеграция AI в 1С:Предприятие

Интегрируйте AI в ваши решения на 1С для автоматизации рутинных задач.

## Возможности интеграции

- Автоматическое заполнение документов
- Генерация отчётов и аналитики
- Классификация номенклатуры
- Обработка обращений клиентов
- Генерация описаний товаров

## Пример на встроенном языке 1С

```1c
// Функция для отправки запроса к AI API
Функция ОтправитьЗапросКAI(Сообщение, Модель = "gpt-5.2") Экспорт
    
    HTTPСоединение = Новый HTTPСоединение("api.aitunnel.ru", 443, , , , 30, Новый ЗащищенноеСоединениеOpenSSL);
    
    Заголовки = Новый Соответствие;
    Заголовки.Вставить("Content-Type", "application/json");
    Заголовки.Вставить("Authorization", "Bearer sk-aitunnel-xxx");
    
    ТелоЗапроса = Новый Структура;
    ТелоЗапроса.Вставить("model", Модель);
    
    Сообщения = Новый Массив;
    СообщениеПользователя = Новый Структура;
    СообщениеПользователя.Вставить("role", "user");
    СообщениеПользователя.Вставить("content", Сообщение);
    Сообщения.Добавить(СообщениеПользователя);
    
    ТелоЗапроса.Вставить("messages", Сообщения);
    
    ЗаписьJSON = Новый ЗаписьJSON;
    ЗаписьJSON.УстановитьСтроку();
    ЗаписатьJSON(ЗаписьJSON, ТелоЗапроса);
    ТелоЗапросаСтрока = ЗаписьJSON.Закрыть();
    
    HTTPЗапрос = Новый HTTPЗапрос("/v1/chat/completions", Заголовки);
    HTTPЗапрос.УстановитьТелоИзСтроки(ТелоЗапросаСтрока, КодировкаТекста.UTF8);
    
    Попытка
        HTTPОтвет = HTTPСоединение.ОтправитьДляОбработки(HTTPЗапрос);
        
        Если HTTPОтвет.КодСостояния = 200 Тогда
            ЧтениеJSON = Новый ЧтениеJSON;
            ЧтениеJSON.УстановитьСтроку(HTTPОтвет.ПолучитьТелоКакСтроку(КодировкаТекста.UTF8));
            Ответ = ПрочитатьJSON(ЧтениеJSON);
            
            Возврат Ответ.choices[0].message.content;
        КонецЕсли;
    Исключение
        Возврат "Ошибка: " + ОписаниеОшибки();
    КонецПопытки;
    
КонецФункции
```

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

### Генерация описания номенклатуры

```1c
Процедура СгенерироватьОписание(Номенклатура)
    
    Запрос = "Напиши продающее описание товара: " + Номенклатура.Наименование;
    Описание = ОтправитьЗапросКAI(Запрос);
    
    Номенклатура.Описание = Описание;
    Номенклатура.Записать();
    
КонецПроцедуры
```

### Классификация обращений

```1c
Функция КлассифицироватьОбращение(ТекстОбращения)
    
    Запрос = "Классифицируй обращение клиента. Категории: жалоба, вопрос, предложение, благодарность.
    Верни только категорию одним словом.
    
    Обращение: " + ТекстОбращения;
    
    Категория = ОтправитьЗапросКAI(Запрос, "gpt-5-mini");
    Возврат СокрЛП(Категория);
    
КонецФункции
```

Интеграция 1С с нейросетью GPT. Автоматизация документов, отчётов. AI API для 1С в России.

1С интеграция с AI | ChatGPT для 1С | AITUNNEL

1С интеграция с нейросетью

Добавление AI в Битрикс24

Интегрируйте ChatGPT в Битрикс24 для автоматизации работы с клиентами и задачами.

## Применение AI в Битрикс24

- Автоматические ответы в чатах
- Генерация описаний задач
- Анализ лидов и сделок
- Составление писем клиентам
- Резюме звонков

## Интеграция через Webhook

```php
<?php
// webhook_handler.php

$apiKey = 'sk-aitunnel-xxx';

function askAI($message, $model = 'gpt-5.2') {
    global $apiKey;
    
    $data = [
        'model' => $model,
        'messages' => [
            ['role' => 'user', 'content' => $message]
        ]
    ];
    
    $ch = curl_init('https://api.aitunnel.ru/v1/chat/completions');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'Authorization: Bearer ' . $apiKey
    ]);
    
    $response = curl_exec($ch);
    $result = json_decode($response, true);
    
    return $result['choices'][0]['message']['content'];
}

// Обработка входящего сообщения из открытой линии
$event = json_decode(file_get_contents('php://input'), true);

if ($event['event'] === 'ONIMBOTMESSAGEADD') {
    $message = $event['data']['PARAMS']['MESSAGE'];
    
    $response = askAI("Ответь на сообщение клиента кратко и по делу: " . $message);
    
    // Отправка ответа через REST API Битрикс24
    // ...
}
?>
```

## Бизнес-процессы

### Автозаполнение задачи

```php
// При создании задачи генерируем описание
$taskTitle = "Подготовить коммерческое предложение для Газпром";

$prompt = "Напиши план задачи (5-7 пунктов): " . $taskTitle;
$description = askAI($prompt);

// Обновляем задачу через REST API
CRest::call('tasks.task.update', [
    'taskId' => $taskId,
    'fields' => ['DESCRIPTION' => $description]
]);
```

### Анализ лида

```php
function analyzeLead($leadData) {
    $prompt = "Проанализируй лид и оцени вероятность сделки (0-100%):
    
    Компания: {$leadData['COMPANY_TITLE']}
    Источник: {$leadData['SOURCE_ID']}
    Комментарий: {$leadData['COMMENTS']}
    Бюджет: {$leadData['OPPORTUNITY']}
    
    Дай оценку и краткое обоснование.";
    
    return askAI($prompt);
}
```

Интеграция Битрикс24 с ChatGPT. AI для CRM, автоматизация задач. GPT API в России.

Битрикс24 + ChatGPT интеграция | AI для CRM | AITUNNEL

Битрикс24 + ChatGPT интеграция

AI функции для вашего WordPress сайта

Добавьте AI возможности на ваш WordPress сайт с помощью AITUNNEL API.

## Возможности AI для WordPress

- Генерация постов и страниц
- SEO-оптимизация контента
- AI чат-бот для посетителей
- Автоматические описания товаров
- Генерация alt-текстов для изображений

## Простой плагин

```php
<?php
/**
 * Plugin Name: AITUNNEL AI Content
 * Description: AI генерация контента через AITUNNEL
 */

class AITUNNEL_AI {
    private $api_key;
    private $api_url = 'https://api.aitunnel.ru/v1/chat/completions';
    
    public function __construct() {
        $this->api_key = get_option('aitunnel_api_key');
        add_action('admin_menu', [$this, 'add_admin_menu']);
        add_action('add_meta_boxes', [$this, 'add_ai_metabox']);
    }
    
    public function generate_content($prompt, $model = 'gpt-5-mini') {
        $response = wp_remote_post($this->api_url, [
            'headers' => [
                'Content-Type' => 'application/json',
                'Authorization' => 'Bearer ' . $this->api_key
            ],
            'body' => json_encode([
                'model' => $model,
                'messages' => [
                    ['role' => 'user', 'content' => $prompt]
                ]
            ]),
            'timeout' => 60
        ]);
        
        if (is_wp_error($response)) {
            return false;
        }
        
        $body = json_decode(wp_remote_retrieve_body($response), true);
        return $body['choices'][0]['message']['content'];
    }
    
    public function add_ai_metabox() {
        add_meta_box(
            'aitunnel_ai_box',
            'AI Генерация',
            [$this, 'render_metabox'],
            'post'
        );
    }
}

new AITUNNEL_AI();
```

## Генерация поста

```php
// Shortcode для генерации контента
add_shortcode('ai_generate', function($atts) {
    $atts = shortcode_atts(['prompt' => ''], $atts);
    $ai = new AITUNNEL_AI();
    return $ai->generate_content($atts['prompt']);
});

// Использование: [ai_generate prompt="Напиши введение о WordPress"]
```

## WooCommerce интеграция

```php
// Автогенерация описаний товаров
add_action('save_post_product', function($post_id) {
    $product = wc_get_product($post_id);
    $title = $product->get_name();
    
    $ai = new AITUNNEL_AI();
    $description = $ai->generate_content(
        "Напиши продающее описание товара: " . $title
    );
    
    $product->set_description($description);
    $product->save();
});
```

Интеграция AI в WordPress. Плагин для генерации контента, SEO, чат-бота. GPT API в России.

WordPress AI плагин | ChatGPT для WordPress | AITUNNEL

WordPress AI плагин

AI возможности для сайтов на Tilda

Добавьте AI чат-бота и другие умные функции на ваш сайт на Tilda.

## Возможности

- AI чат-бот для посетителей
- Умные формы с AI обработкой
- Генерация контента
- Персонализация

## AI чат-бот для Tilda

Добавьте этот код в раздел "HTML-код перед </body>":

```html
<div id="ai-chat-widget"></div>
<script>
(function() {
  const API_KEY = 'sk-aitunnel-xxx'; // Используйте серверную прослойку!
  const API_URL = 'https://api.aitunnel.ru/v1/chat/completions';
  
  // Создаём виджет чата
  const widget = document.createElement('div');
  widget.innerHTML = `
    <div id="chat-toggle" style="position:fixed;bottom:20px;right:20px;width:60px;height:60px;
      background:#4F46E5;border-radius:50%;cursor:pointer;display:flex;align-items:center;
      justify-content:center;box-shadow:0 4px 12px rgba(0,0,0,0.15);z-index:9999;">
      <svg width="24" height="24" fill="white" viewBox="0 0 24 24">
        <path d="M20 2H4c-1.1 0-2 .9-2 2v18l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2z"/>
      </svg>
    </div>
    <div id="chat-window" style="display:none;position:fixed;bottom:90px;right:20px;
      width:350px;height:450px;background:white;border-radius:12px;
      box-shadow:0 4px 24px rgba(0,0,0,0.15);z-index:9999;flex-direction:column;">
      <div style="padding:16px;background:#4F46E5;color:white;border-radius:12px 12px 0 0;">
        AI Консультант
      </div>
      <div id="chat-messages" style="flex:1;overflow-y:auto;padding:16px;"></div>
      <div style="padding:12px;border-top:1px solid #eee;display:flex;gap:8px;">
        <input id="chat-input" type="text" placeholder="Введите сообщение..."
          style="flex:1;padding:8px 12px;border:1px solid #ddd;border-radius:8px;">
        <button id="chat-send" style="padding:8px 16px;background:#4F46E5;color:white;
          border:none;border-radius:8px;cursor:pointer;">→</button>
      </div>
    </div>
  `;
  document.body.appendChild(widget);
  
  // Логика чата
  const toggle = document.getElementById('chat-toggle');
  const window = document.getElementById('chat-window');
  const messages = document.getElementById('chat-messages');
  const input = document.getElementById('chat-input');
  const send = document.getElementById('chat-send');
  
  toggle.onclick = () => {
    window.style.display = window.style.display === 'none' ? 'flex' : 'none';
  };
  
  async function sendMessage() {
    const text = input.value.trim();
    if (!text) return;
    
    messages.innerHTML += `<div style="margin:8px 0;text-align:right;">
      <span style="background:#4F46E5;color:white;padding:8px 12px;border-radius:12px;
        display:inline-block;max-width:80%;">${text}</span></div>`;
    input.value = '';
    
    // Отправка в AI
    const response = await fetch(API_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer ' + API_KEY
      },
      body: JSON.stringify({
        model: 'gpt-5-mini',
        messages: [{
          role: 'system',
          content: 'Ты консультант на сайте. Отвечай кратко и помогай посетителям.'
        }, {
          role: 'user',
          content: text
        }]
      })
    });
    
    const data = await response.json();
    const reply = data.choices[0].message.content;
    
    messages.innerHTML += `<div style="margin:8px 0;">
      <span style="background:#f1f1f1;padding:8px 12px;border-radius:12px;
        display:inline-block;max-width:80%;">${reply}</span></div>`;
    messages.scrollTop = messages.scrollHeight;
  }
  
  send.onclick = sendMessage;
  input.onkeypress = (e) => e.key === 'Enter' && sendMessage();
})();
</script>
```

## Важно: Безопасность

Не храните API ключ в клиентском коде! Создайте серверную прослойку:

```javascript
// Используйте Cloudflare Workers или свой backend
const API_URL = 'https://your-backend.com/api/chat';
```

## Умная форма

Обрабатывайте заявки с Tilda форм через AI:

```javascript
// Webhook для обработки формы
// Добавьте в Tilda: Настройки формы → Webhook
```

Интеграция AI с Tilda. Чат-бот, генерация контента, формы с AI. GPT API для Tilda в России.

Интеграции с фреймворками