Self-hosted AI-платформа: полный стек для локального ИИ на Docker

Введение

При внедрении ИИ-решений для бизнеса постоянно сталкивался с проблемой: компании хотят использовать LLM, но не могут отправлять конфиденциальные данные в публичные облачные сервисы. 152-ФЗ, NDA, корпоративные политики безопасности — причины разные, суть одна: нужна локальная инфраструктура.

Существующие решения требовали либо глубокой технической экспертизы (ручная сборка из отдельных компонентов), либо значительных бюджетов (enterprise-платформы от $50k+). Взял за основу несколько open source проектов (n8n-io/self-hosted-ai-starter-kit, coleam00/local-ai-packaged) и собрал готовое решение с оптимизациями для русскоязычного комьюнити.

В статье разберу финальную архитектуру, интеграцию компонентов, benchmark новых моделей (декабрь 2025) и production-решения для реальных задач.

Техническая архитектура

Система построена по микросервисной архитектуре. Все компоненты в изолированной Docker-сети localai_default:

┌──────────────────────────────────────────────────┐
│              Caddy (HTTPS/SSL)                   │
│              ports: 80, 443, 8001-8005           │
└──────────────────────┬───────────────────────────┘
                       │
┌──────────────────────▼─────────────────────────��──┐
│             localai_default network               │
│                                                   │
│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐ │
│  │   N8N    │  │ Whisper  │  │    Supabase      │ │
│  │ +FFmpeg  │  │  :8000   │  │  :8000 (Kong)    │ │
│  │  :5678   │  │          │  │  - PostgreSQL    │ │
│  │          │  │          │  │  - pgvector      │ │
│  └──────────┘  └──────────┘  │  - Auth          │ │
│                              └──────────────────┘ │
│                                                   │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐         │
│  │  Ollama  │  │ OpenWebUI│  │ Qdrant   │         │
│  │  :11434  │  │  :8080   │  │  :6333   │         │
│  └──────────┘  └──────────┘  └──────────┘         │
│                                                   │
│  ┌──────────┐  ┌──────────┐                       │
│  │PostgreSQL│  │  Redis   │                       │
│  │  :5432   │  │  :6379   │                       │
│  │ (N8N DB) │  │(cache/q) │                       │
│  └──────────┘  └──────────┘                       │
└───────────────────────────────────────────────────┘

Компоненты стека

N8N + FFmpeg — ядро автоматизации. N8N предоставляет 400+ интеграций, визуальный редактор workflows. FFmpeg встроен в кастомный образ для обработки медиа (конвертация аудио/видео). Собственная PostgreSQL база для хранения workflow и выполнений.

Ollama — локальный LLM сервер. Управление моделями одной командой (ollama pull <model>). Поддержка GGUF квантизации, автоматическое определение GPU (NVIDIA/AMD). API совместимый с OpenAI.

Open WebUI — ChatGPT-подобный интерфейс. Встроенная поддержка RAG, управление промптами, история диалогов. Интеграция с N8N через Pipe Functions — можно вызывать N8N workflows прямо из чата.

Supabase — PostgreSQL с полным стеком:

• pgvector для векторного поиска

• Kong API Gateway

• Встроенная аутентификация

• Storage для файлов

• Realtime subscriptions

Qdrant — специализированная векторная БД. Написана на Rust, оптимизирована для высокой нагрузки. HNSW индекс для быстрого similarity search. Поддержка quantization для экономии памяти.

Whisper (faster-whisper-server) — оптимизированный сервер для STT. OpenAI-совместимый API. Модели: tiny/base/small/medium. Работает на CPU, base модель рекомендуется для production.

Redis — кеш и очереди. Используется N8N для queue mode, кеширование промежуточных результатов.

Caddy — reverse proxy с автоматическим HTTPS. Zero-config Let's Encrypt сертификаты. Маршрутизация по поддоменам или портам.

Docker Compose: конфигурация и управление

Автоматическая установка

Проект включает Python-скрипт CTAPT.py для автоматической настройки:

# Основные задачи установщика:
# 1. Проверка системных требований
# 2. Определение GPU (NVIDIA/AMD) 
# 3. Генерация всех секретных ключей
# 4. Создание .env с параметрами
# 5. Запуск Docker контейнеров
# 6. Создание shared директории с правами 777
# 7. Автозагрузка базовых моделей

# Клонирование и установка:
git clone https://github.com/shorin-nikita/lisa.git
cd lisa
python3 CTAPT.py

Базовая структура docker-compose.yml

version: '3.8'

services:
  # N8N с FFmpeg для обработки медиа
  n8n:
    image: custom-n8n-ffmpeg  # Кастомный образ с FFmpeg
    container_name: n8n
    volumes:
      - n8n_data:/home/node/.n8n
      - ./shared:/data/shared  # Общая директория для файлов
    environment:
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=n8n-postgres
      - EXECUTIONS_MODE=regular  # или queue для высокой нагрузки
    networks:
      - localai_default
    restart: unless-stopped

  # Ollama для локальных LLM
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    networks:
      - localai_default
    restart: unless-stopped

  # Open WebUI с интеграцией Ollama
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    volumes:
      - open-webui_data:/app/backend/data
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY}
      - ENABLE_RAG_WEB_SEARCH=True
    networks:
      - localai_default
    depends_on:
      - ollama
    restart: unless-stopped

  # Whisper для распознавания речи
  whisper:
    image: fedirz/faster-whisper-server:latest
    container_name: whisper
    volumes:
      - whisper_data:/root/.cache/whisper
    environment:
      - MODEL=base  # tiny/base/small/medium
    networks:
      - localai_default
    restart: unless-stopped

  # Qdrant векторная БД
  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant
    volumes:
      - qdrant_data:/qdrant/storage
    networks:
      - localai_default
    restart: unless-stopped

  # Supabase (PostgreSQL + Kong + Auth + Storage)
  supabase:
    image: supabase/postgres:15.1.0.117
    container_name: supabase-db
    volumes:
      - supabase_db_data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: postgres
    command: postgres -c shared_preload_libraries=vector
    networks:
      - localai_default
    restart: unless-stopped

  # Redis для кеша и очередей
  redis:
    image: redis:alpine
    container_name: redis
    command: redis-server --maxmemory 2gb --maxmemory-policy allkeys-lru
    networks:
      - localai_default
    restart: unless-stopped

  # Caddy для HTTPS
  caddy:
    image: caddy:alpine
    container_name: caddy
    ports:
      - "80:80"
      - "443:443"
      - "8001:8001"  # N8N
      - "8002:8002"  # Open WebUI
      - "8005:8005"  # Supabase
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    networks:
      - localai_default
    restart: unless-stopped

networks:
  localai_default:
    driver: bridge

volumes:
  n8n_data:
  ollama_data:
  open-webui_data:
  whisper_data:
  qdrant_data:
  supabase_db_data:
  caddy_data:
  caddy_config:

Модели по умолчанию

При первом запуске автоматически загружаются:

Gemma 3 1B — компактная LLM от Google

• Размер: ~1 GB

• Параметры: 1 миллиард

• Квантизация: Q4_0

• RAM requirement: 2-3 GB

• Использование: генерация текста, диалоги, простые задачи

• Особенность: работает даже на минимальной конфигурации (2 CPU / 8GB RAM)

nomic-embed-text — модель эмбеддингов

• Размер: ~274 MB

• Использование: векторизация для RAG, семантический поиск

• Размерность: 768

• Поддержка: английский и основные европейские языки

# Автоматическая установка моделей:
docker exec -it ollama ollama pull gemma3:1b
docker exec -it ollama ollama pull nomic-embed-text

# Проверка установленных моделей:
docker exec -it ollama ollama list

Топовые LLM модели декабря 2025

DeepSeek-R1 (лидер по рассуждениям)

Революционная модель для сложной логики, математики и кода. Производительность близка к GPT-4.

# Установка:
docker exec -it ollama ollama pull deepseek-r1:7b   # 4.7 GB
docker exec -it ollama ollama pull deepseek-r1:14b  # 8.9 GB
docker exec -it ollama ollama pull deepseek-r1:70b  # 40 GB (GPU required)

Характеристики:

• Параметры: 7B / 14B / 70B версии

• Контекст: 128K токенов

• Обучение: 18T токенов

• Особенность: Chain-of-thought reasoning из коробки

• Лучшая для: математика, код, логические задачи, анализ

Benchmark (70B vs GPT-4):

• Coding (HumanEval): 89% vs 92%

• Math (MATH): 86% vs 88%

• Reasoning (GPQA): 84% vs 87%

Llama 3.3 70B (новый флагман Meta)

Свежая модель от Meta, сопоставимая с Llama 3.1 405B по качеству, но гораздо эффективнее.

docker exec -it ollama ollama pull llama3.3:70b  # 40 GB
docker exec -it ollama ollama pull llama3.3:70b-instruct-q4_K_M  # 39 GB (квантизация)

Характеристики:

• Параметры: 70 миллиардов

• Контекст: 128K токенов

• Квантизация: Q4_K_M, Q5_K_M, Q8_0

• Особенность: качество 405B модели при размере 70B

• Лучшая для: универсальные задачи, длинный контекст, инструкции

RAM requirements:

• FP16: 140 GB (непрактично)

• Q8_0: 74 GB

• Q4_K_M: 39 GB (оптимально для RTX 4090)

• Q4_0: 35 GB (минимально)

Llama 3.1 (проверенный универсал)

Стабильная, проверенная временем модель. Топ для большинства задач.

# Различные размеры:
docker exec -it ollama ollama pull llama3.1:8b     # 4.7 GB - быстрая, CPU-friendly
docker exec -it ollama ollama pull llama3.1:70b    # 40 GB - высокое качество
docker exec -it ollama ollama pull llama3.1:405b   # 231 GB - максимальное качество

Когда выбирать:

• 8B: CPU-серверы, быстрые ответы, RAG-задачи

• 70B: GPU с 24GB+ VRAM, сложные задачи

• 405B: multi-GPU setup, критичное качество

Qwen 2.5 Coder / Qwen 3 (программирование)

Лучшая модель для кросс-языкового программирования и многоязычного контента.

docker exec -it ollama ollama pull qwen2.5-coder:7b   # 4.7 GB
docker exec -it ollama ollama pull qwen2.5-coder:14b  # 9.0 GB
docker exec -it ollama ollama pull qwen2.5-coder:32b  # 19 GB

Особенности:

• Поддержка 80+ языков программирования

• Отличный русский язык (лучше Llama)

• Fill-in-middle для автодополнения

• Длинный контекст: 128K токенов

Benchmark (Qwen2.5-Coder-32B):

• HumanEval: 92.7% (выше Claude Sonnet)

• MBPP: 88.6%

• LiveCodeBench: 45.3%

Mistral 7B Instruct (бюджетный вариант)

Быстрая и эффективная модель для бюджетных систем и прототипирования.

docker exec -it ollama ollama pull mistral:7b  # 4.1 GB
docker exec -it ollama ollama pull mistral:7b-instruct-q4_0  # 3.8 GB

Преимущества:

• Минимальные требования: 8GB RAM

• Работает на CPU за приемлемое время (15-20 сек/ответ)

• Хорошее качество для своего размера

• Контекст: 32K токенов

Phi-3 (Microsoft, сверхлегкая)

Сверхлегкая модель с качеством больших моделей. Работает даже на смартфоне.

docker exec -it ollama ollama pull phi3:mini      # 2.2 GB (3.8B)
docker exec -it ollama ollama pull phi3:medium    # 7.9 GB (14B)

Особенности:

• Обучена на синтетических данных высокого качества

• Отличное следование инструкциям

• Низкая latency

• Контекст: 128K токенов

Идеально для:

• Встраиваемые системы

• Edge computing

• Мобильные устройства

• Прототипирование

Gemma 2 / Gemma 3 (Google, компактность)

Семейство компактных моделей от Google для чатов и диалогов.

# Gemma 2:
docker exec -it ollama ollama pull gemma2:2b  # 1.6 GB
docker exec -it ollama ollama pull gemma2:9b  # 5.5 GB

# Gemma 3 (новая версия):
docker exec -it ollama ollama pull gemma3:1b  # 1.0 GB (по умолчанию в проекте)
docker exec -it ollama ollama pull gemma3:3b  # 2.0 GB

Версии:

• 1B: минимальная конфигурация, быстрые ответы

• 2B: баланс скорости и качества

• 3B: улучшенное понимание контекста

• 9B: близко к моделям 13B

Рекомендации по выбору модели

Для разных задач

RAG и работа с документами:

Первый выбор: Llama 3.1 8B (быстро, точно)
Альтернатива: Qwen 2.5 7B (лучше русский)
Бюджет: Gemma 2 9B (компактно)

Программирование:

Первый выбор: Qwen 2.5 Coder 14B
Альтернатива: DeepSeek-R1 14B
Бюджет: Qwen 2.5 Coder 7B

Математика и логика:

Первый выбор: DeepSeek-R1 70B
Альтернатива: Llama 3.3 70B
Бюджет: DeepSeek-R1 14B

Универсальные задачи:

Первый выбор: Llama 3.3 70B (лучший баланс)
Альтернатива: Llama 3.1 70B
Бюджет: Mistral 7B

CPU-only конфигурация:

Первый выбор: Phi-3 Mini (3.8B)
Альтернатива: Gemma 3 3B
Максимум: Mistral 7B (медленно, но работает)

По железу

Минимальная конфигурация (2 CPU / 8GB RAM):

• Gemma 3 1B — работает комфортно

• Phi-3 Mini — альтернатива

• Скорость: 20-40 секунд на ответ

Средняя конфигурация (4 CPU / 16GB RAM):

• Mistral 7B — основная модель

• Qwen 2.5 7B — для русского языка

• Llama 3.1 8B — универсальная

• Скорость: 15-25 секунд на ответ

RTX 3060 (12GB VRAM):

• Llama 3.1 8B — быстро (45+ tokens/sec)

• Qwen 2.5 Coder 14B — программирование

• Mistral Nemo 12B — универсал

• Скорость: 1-3 секунды первый токен

RTX 4090 (24GB VRAM):

• Llama 3.3 70B — топ качество

• DeepSeek-R1 70B — сложные задачи

• Qwen 2.5 Coder 32B — код

• Скорость: 15-25 tokens/sec

Multi-GPU (2x RTX 4090):

• Llama 3.1 405B — максимальное качество

• Возможна параллельная обработка запросов

Автоматизация развёртывания: CTAPT.py

Скрипт CTAPT.py полностью автоматизирует процесс установки. Разберём ключевые части:

#!/usr/bin/env python3
import os
import subprocess
import secrets
import platform
import shutil

class LISAInstaller:
    def __init__(self):
        self.has_nvidia_gpu = self.detect_nvidia_gpu()
        self.has_amd_gpu = self.detect_amd_gpu()
        self.config = {}
        
    def detect_nvidia_gpu(self):
        """Определяет наличие NVIDIA GPU"""
        try:
            result = subprocess.run(
                ['nvidia-smi'], 
                capture_output=True, 
                text=True,
                timeout=5
            )
            if result.returncode == 0:
                print("✅ NVIDIA GPU обнаружен")
                return True
        except (FileNotFoundError, subprocess.TimeoutExpired):
            pass
        print("❌ NVIDIA GPU не обнаружен")
        return False
    
    def detect_amd_gpu(self):
        """Определяет наличие AMD GPU"""
        try:
            result = subprocess.run(
                ['rocm-smi'], 
                capture_output=True,
                text=True,
                timeout=5
            )
            if result.returncode == 0:
                print("✅ AMD GPU обнаружен")
                return True
        except (FileNotFoundError, subprocess.TimeoutExpired):
            pass
        return False
    
    def generate_secrets(self):
        """Генерирует криптографически стойкие ключи"""
        secrets_dict = {
            'WEBUI_SECRET_KEY': secrets.token_urlsafe(32),
            'N8N_ENCRYPTION_KEY': secrets.token_urlsafe(32),
            'POSTGRES_PASSWORD': secrets.token_urlsafe(16),
            'JWT_SECRET': secrets.token_urlsafe(64),
            'ANON_KEY': self.generate_supabase_key('anon'),
            'SERVICE_ROLE_KEY': self.generate_supabase_key('service_role')
        }
        return secrets_dict
    
    def generate_supabase_key(self, role):
        """Генерирует JWT токены для Supabase"""
        import jwt
        import time
        
        payload = {
            'role': role,
            'iss': 'supabase',
            'iat': int(time.time()),
            'exp': int(time.time()) + (10 * 365 * 24 * 60 * 60)  # 10 лет
        }
        
        token = jwt.encode(payload, self.config['JWT_SECRET'], algorithm='HS256')
        return token
    
    def create_env_file(self):
        """Создаёт .env файл с конфигурацией"""
        secrets_dict = self.generate_secrets()
        
        # Интерактивный ввод доменов
        use_domains = input("Использовать домены для HTTPS? (y/n): ").lower() == 'y'
        
        with open('.env', 'w') as f:
            # Секреты
            for key, value in secrets_dict.items():
                f.write(f"{key}={value}\n")
            
            # Домены
            if use_domains:
                n8n_domain = input("N8N домен (например n8n.example.com): ")
                webui_domain = input("Open WebUI домен (например webui.example.com): ")
                email = input("Email для Let's Encrypt: ")
                
                f.write(f"\nN8N_HOSTNAME={n8n_domain}\n")
                f.write(f"WEBUI_HOSTNAME={webui_domain}\n")
                f.write(f"LETSENCRYPT_EMAIL={email}\n")
            else:
                f.write("\n# Локальный доступ через порты\n")
                f.write("N8N_HOSTNAME=localhost\n")
                f.write("WEBUI_HOSTNAME=localhost\n")
            
            # GPU конфигурация
            if self.has_nvidia_gpu:
                f.write("\nGPU_TYPE=nvidia\n")
            elif self.has_amd_gpu:
                f.write("\nGPU_TYPE=amd\n")
            else:
                f.write("\nGPU_TYPE=none\n")
        
        print("✅ Файл .env создан")
    
    def setup_shared_directory(self):
        """Создаёт общую директорию для файлов с правильными правами"""
        shared_dir = os.path.join(os.getcwd(), 'shared')
        
        if not os.path.exists(shared_dir):
            os.makedirs(shared_dir)
        
        # Права 777 для доступа из Docker контейнеров
        os.chmod(shared_dir, 0o777)
        print(f"✅ Создана директория {shared_dir} с правами 777")
    
    def build_custom_images(self):
        """Собирает кастомные образы (n8n с FFmpeg)"""
        print("? Сборка кастомных образов...")
        
        # Dockerfile для N8N с FFmpeg
        n8n_dockerfile = """
FROM n8nio/n8n:latest

USER root

# Установка FFmpeg
RUN apk add --no-cache ffmpeg

# Создание директории для shared файлов
RUN mkdir -p /data/shared && chmod 777 /data/shared

USER node
"""
        
        with open('n8n.Dockerfile', 'w') as f:
            f.write(n8n_dockerfile)
        
        subprocess.run([
            'docker', 'build',
            '-t', 'custom-n8n-ffmpeg',
            '-f', 'n8n.Dockerfile',
            '.'
        ])
        
        os.remove('n8n.Dockerfile')
        print("✅ Кастомные образы собраны")
    
    def start_services(self):
        """Запускает Docker Compose"""
        print("? Запуск сервисов...")
        subprocess.run([
            'docker-compose',
            '-p', 'localai',
            'up', '-d'
        ])
        print("✅ Сервисы запущены")
    
    def download_default_models(self):
        """Загружает базовые модели"""
        print("? Загрузка базовых моделей...")
        
        models = ['gemma3:1b', 'nomic-embed-text']
        
        for model in models:
            print(f"  Загружается {model}...")
            subprocess.run([
                'docker', 'exec', 'ollama',
                'ollama', 'pull', model
            ])
        
        print("✅ Базовые модели загружены")
    
    def run(self):
        """Главный метод установки"""
        print("=" * 50)
        print("Л.И.С.А. - Установщик")
        print("=" * 50)
        
        # Проверки
        self.check_requirements()
        
        # Настройка
        self.create_env_file()
        self.setup_shared_directory()
        
        # Сборка и запуск
        self.build_custom_images()
        self.start_services()
        
        # Ожидание запуска Ollama
        print("⏳ Ожидание запуска Ollama...")
        import time
        time.sleep(30)
        
        # Загрузка моделей
        if input("Загрузить базовые модели? (y/n): ").lower() == 'y':
            self.download_default_models()
        
        print("\n" + "=" * 50)
        print("✅ Установка завершена!")
        print("=" * 50)
        print("\n? Доступ к сервисам:")
        print("  N8N: http://localhost:8001")
        print("  Open WebUI: http://localhost:8002")
        print("  Supabase: http://localhost:8005")
        print("\n? Документация: https://github.com/shorin-nikita/lisa")
    
    def check_requirements(self):
        """Проверяет системные требования"""
        # Проверка Docker
        try:
            result = subprocess.run(['docker', '--version'], capture_output=True)
            if result.returncode != 0:
                raise Exception("Docker не установлен")
        except FileNotFoundError:
            print("❌ Docker не найден. Установите Docker: https://docs.docker.com/get-docker/")
            exit(1)
        
        # Проверка Docker Compose
        try:
            result = subprocess.run(['docker-compose', '--version'], capture_output=True)
            if result.returncode != 0:
                raise Exception("Docker Compose не установлен")
        except FileNotFoundError:
            print("❌ Docker Compose не найден")
            exit(1)
        
        print("✅ Системные требования проверены")

if __name__ == "__main__":
    installer = LISAInstaller()
    installer.run()

Обновление системы: O6HOBA.py

Для обновления существующей установки используется O6HOBA.py:

#!/usr/bin/env python3
import subprocess
import os
from datetime import datetime

class LISAUpdater:
    def backup_data(self):
        """Создаёт резервную копию перед обновлением"""
        backup_dir = f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        os.makedirs(backup_dir)
        
        # Бэкап .env
        if os.path.exists('.env'):
            shutil.copy('.env', f"{backup_dir}/.env")
        
        print(f"✅ Резервная копия создана: {backup_dir}")
    
    def update(self):
        print("? Обновление Л.И.С.А...")
        
        # Бэкап
        self.backup_data()
        
        # Остановка сервисов
        subprocess.run(['docker-compose', '-p', 'localai', 'down'])
        
        # Получение обновлений
        subprocess.run(['git', 'pull', 'origin', 'main'])
        
        # Обновление образов
        subprocess.run(['docker-compose', '-p', 'localai', 'pull'])
        
        # Пересборка кастомных образов
        subprocess.run([
            'docker', 'build',
            '-t', 'custom-n8n-ffmpeg',
            '-f', 'n8n.Dockerfile',
            '.'
        ])
        
        # Запуск
        subprocess.run(['docker-compose', '-p', 'localai', 'up', '-d'])
        
        print("✅ Обновление завершено!")

if __name__ == "__main__":
    updater = LISAUpdater()
    updater.update()

RAG: техническая реализация

Retrieval-Augmented Generation — технология, при которой LLM отвечает на основе внешних документов, а не только обученных данных.

Архитектура RAG-пайплайна

Документ → Chunking → Embedding → Vector DB
                                       │
Вопрос → Embedding → Similarity Search ┘
              │
              ▼
         Top-K chunks + Вопрос → LLM → Ответ

Реализация в Open WebUI

Open WebUI имеет встроенную поддержку RAG, но для production использования я доработал пайплайн:

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams

class RAGPipeline:
    def __init__(self):
        self.text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            separators=["\n\n", "\n", " ", ""]
        )
        
        self.embeddings = HuggingFaceEmbeddings(
            model_name="sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
        )
        
        self.qdrant = QdrantClient(host="qdrant", port=6333)
    
    def process_document(self, document_text, document_id):
        """Обрабатывает документ и сохраняет в векторную БД"""
        
        # Разбиваем на чанки
        chunks = self.text_splitter.split_text(document_text)
        
        # Создаём эмбеддинги
        embeddings = self.embeddings.embed_documents(chunks)
        
        # Создаём коллекцию если не существует
        try:
            self.qdrant.create_collection(
                collection_name="documents",
                vectors_config=VectorParams(
                    size=768,  # размерность эмбеддингов
                    distance=Distance.COSINE
                )
            )
        except:
            pass
        
        # Сохраняем в Qdrant
        points = [
            {
                "id": f"{document_id}_{i}",
                "vector": embedding,
                "payload": {
                    "text": chunk,
                    "document_id": document_id,
                    "chunk_index": i
                }
            }
            for i, (chunk, embedding) in enumerate(zip(chunks, embeddings))
        ]
        
        self.qdrant.upsert(
            collection_name="documents",
            points=points
        )
    
    def search(self, query, top_k=5):
        """Ищет релевантные чанки для запроса"""
        
        # Создаём эмбеддинг запроса
        query_embedding = self.embeddings.embed_query(query)
        
        # Ищем похожие векторы
        results = self.qdrant.search(
            collection_name="documents",
            query_vector=query_embedding,
            limit=top_k
        )
        
        return [hit.payload["text"] for hit in results]
    
    def generate_response(self, query, context_chunks, model="llama3.1:8b"):
        """Генерирует ответ на основе найденных чанков"""
        
        context = "\n\n".join(context_chunks)
        
        prompt = f"""Используя только информацию из контекста ниже, ответь на вопрос. 
Если ответа нет в контексте, скажи "Информация не найдена в документах".

Контекст:
{context}

Вопрос: {query}

Ответ:"""
        
        # Вызов Ollama через API
        import requests
        response = requests.post(
            "http://ollama:11434/api/generate",
            json={
                "model": model,
                "prompt": prompt,
                "stream": False
            }
        )
        
        return response.json()["response"]

Оптимизация RAG для production

Проблема 1: Медленный поиск при большом количестве документов.

Решение: Используем HNSW индекс в Qdrant:

self.qdrant.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=768,
        distance=Distance.COSINE
    ),
    hnsw_config={
        "m": 16,  # количество связей
        "ef_construct": 100  # точность построения индекса
    }
)

Проблема 2: Плохое качество ответов при большом количестве чанков.

Решение: Реранжирование результатов:

from sentence_transformers import CrossEncoder

class ImprovedRAG(RAGPipeline):
    def __init__(self):
        super().__init__()
        self.reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
    
    def search_with_rerank(self, query, top_k=5, rerank_top=20):
        # Получаем больше кандидатов
        candidates = super().search(query, top_k=rerank_top)
        
        # Реранжируем
        pairs = [[query, chunk] for chunk in candidates]
        scores = self.reranker.predict(pairs)
        
        # Возвращаем top-k после реранжирования
        ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
        return [chunk for chunk, score in ranked[:top_k]]

Интеграция Open WebUI с N8N через Pipe Functions

Уникальная фича проекта — можно вызывать N8N workflows прямо из чата Open WebUI.

Архитектура интеграции

User в Open WebUI
      │
      ▼
Pipe Function (Python)
      │
      ▼
N8N Webhook
      │
      ▼
Custom Workflow
 (RAG/API/Automation)
      │
      ▼
Response → Open WebUI

Реализация Pipe Function

Файл n8n_pipe.py в корне проекта:

from typing import List, Union, Generator, Iterator
from pydantic import BaseModel
import requests

class Pipe:
    class Valves(BaseModel):
        n8n_url: str = "http://localhost:8001/webhook/your-webhook-id"
        n8n_bearer_token: str = ""
        input_field: str = "chatInput"
        response_field: str = "output"

    def __init__(self):
        self.name = "N8N Integration"
        self.valves = self.Valves()

    def pipe(
        self, user_message: str, model_id: str, messages: List[dict], body: dict
    ) -> Union[str, Generator, Iterator]:
        
        # Подготовка payload для N8N
        payload = {
            self.valves.input_field: user_message,
            "messages": messages,
            "model": model_id
        }
        
        # Заголовки
        headers = {"Content-Type": "application/json"}
        if self.valves.n8n_bearer_token:
            headers["Authorization"] = f"Bearer {self.valves.n8n_bearer_token}"
        
        try:
            # Вызов N8N webhook
            response = requests.post(
                self.valves.n8n_url,
                json=payload,
                headers=headers,
                timeout=120
            )
            
            if response.status_code == 200:
                result = response.json()
                return result.get(self.valves.response_field, "No response field found")
            else:
                return f"N8N Error: {response.status_code} - {response.text}"
                
        except Exception as e:
            return f"Connection error: {str(e)}"

Настройка в Open WebUI

1. Откройте Open WebUI → Workspace → Functions

2. Add Function → вставьте код из n8n_pipe.py

3. Настройте параметры:

   • n8n_url: Production webhook URL из N8N

   • n8n_bearer_token: токен безопасности (опционально)

4. Активируйте функцию

5. Выберите её из списка моделей в чате

Примеры N8N Workflows для интеграции

1. RAG с векторным поиском:

Webhook → Extract Query → Qdrant Search → Ollama Generate → Response

2. Внешний API + LLM:

Webhook → HTTP Request (API) → Format Data → Ollama Analyze → Response

3. Мульти-агентный workflow:

Webhook → Agent 1 (Research) → Agent 2 (Analyze) → Agent 3 (Summarize) → Response

Готовые Workflows из репозитория

Проект включает готовые workflows в n8n/backup/workflows/:

1. Telegram Bot.json

Полнофункциональный Telegram бот с памятью и аналитикой.

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

• ✅ Текстовые ответы с контекстом (PostgreSQL Memory)

• ✅ Транскрибация голосовых через Whisper

• ✅ Анализ изображений (GPT-4o Vision API)

• ✅ Message Buffer (группировка сообщений, 10 сек)

• ✅ Статус "печатает..." во время обработки

• ✅ Аналитические команды: /stats, /today, /funnel, /users

• ✅ Автологирование в PostgreSQL

Workflow структура:

Telegram Trigger
      │
      ▼
Message Type Check
   ├─► Text → Memory Load → Ollama → Memory Save → Send
   ├─► Voice → Whisper → Memory → Ollama → Send
   └─► Photo → Vision API → Analyze → Send

2. HTTP Handle.json

Настройка webhooks для различных платформ.

Поддерживаемые платформы:

• Telegram Bot

• Wazzup24 (WhatsApp, Instagram, VK, Avito)

3. Конвертация WebM → OGG + Транскрибация.json

Обработка видео с автоматической транскрибацией.

Особенности:

• ✅ Конвертация через FFmpeg (встроен в N8N)

• ✅ Экстремальное сжатие: 95% экономия (32 kbit/s, mono)

• ✅ Оптимизация для голоса

• ✅ Автотранскрибация через Whisper

• ✅ Работа в /tmp без сохранения на диск

Workflow:

Input (WebM) → FFmpeg Convert → Whisper STT → Return Text + Audio

Пример FFmpeg команды:

ffmpeg -i input.webm \
  -vn \  # Без видео
  -codec:a libopus \  # Opus кодек
  -b:a 32k \  # Битрейт 32 kbit/s
  -ac 1 \  # Mono
  -ar 16000 \  # Sample rate 16 kHz
  -application voip \  # Оптимизация для голоса
  output.ogg

4. RAG AI Agents (3 версии)

V1: Local RAG AI Agent

• Базовый RAG с локальными моделями

• Qdrant для векторного поиска

• Ollama для генерации

V2: Supabase RAG AI Agent

• RAG с pgvector (Supabase)

• PostgreSQL для хранения эмбеддингов

• Интеграция с Auth

V3: Agentic RAG AI Agent

• Продвинутый агентный подход

• Множественные инструменты

• Memory между запросами

• Самокоррекция ответов

Автоматический импорт workflows

При первом запуске контейнер n8n-import автоматически импортирует все workflows:

n8n-import:
  image: n8nio/n8n:latest
  command: >
    sh -c "
    n8n import:workflow --input=/backup/workflows/*.json --separate;
    "
  volumes:
    - ./n8n/backup:/backup
    - n8n_data:/home/node/.n8n
  depends_on:
    - n8n

Benchmark: производительность моделей (декабрь 2025)

Тестирование на разном железе для понимания реальной производительности с новыми моделями.

Конфигурация 1: CPU-only (Intel i7-12700K, 32GB RAM)

Выводы CPU:

• Gemma 3 1B — лучший выбор для CPU (комфортная скорость)

• Phi-3 Mini — отличный баланс качества и скорости

• Модели 7B+ работают, но медленно (приемлемо для асинхронных задач)

Конфигурация 2: NVIDIA RTX 3060 (12GB VRAM)

Выводы RTX 3060:

• Ком��ортная работа с моделями до 14B параметров

• Llama 3.1 8B — максимальная скорость

• Qwen 2.5 Coder 14B — лучший баланс для кода

Конфигурация 3: NVIDIA RTX 4090 (24GB VRAM)

Выводы RTX 4090:

• Топовые модели 70B работают с приемлемой скоростью

• Квантизация Q4 критична для размещения в 24GB

• Модели 32B — sweet spot (высокое качество + скорость)

Конфигурация 4: 2x RTX 4090 (48GB VRAM total)

*Используется комбинация VRAM + системной RAM (offloading)

Сравнение качества: локальные vs облачные (2025)

Тестирование на 200 реальных запросов из техподдержки и RAG-задач.

Метрики оценки

• Точность — процент правильных ответов

• Полнота — наличие всех важных деталей

• Релевантность — соответствие ответа вопросу

• Latency — время до первого токена

Результаты RAG задач (декабрь 2025)

*На RTX 4090

Результаты кодирования (HumanEval)

Важный вывод: Qwen 2.5 Coder 32B превосходит Claude Sonnet в задачах кодирования!

Математика и reasoning (MATH dataset)

Вывод: DeepSeek-R1 70B почти достигает уровня GPT-4 в математике!

Выводы по качеству

Для RAG задач:

• Модели 14B+ дают приемлемые 80%+ точности

• Разница с GPT-4 в 10-15%, что для многих сценариев допустимо

• Llama 3.3 70B приближается вплотную к облачным моделям

Для программирования:

• Qwen 2.5 Coder — лучший выбор, превосходит многие облачные модели

• DeepSeek-R1 показывает отличные результаты в сложных задачах

• Модели 32B достаточно для большинства задач кодирования

Для математики и логики:

• DeepSeek-R1 70B — революция в reasoning

• Разница с топовыми облачными моделями минимальна

• Chain-of-thought из коробки значительно улучшает качество

Интеграция с коммерческими API

Система поддерживает гибридный подход: локальные модели для конфиденциальных данных, облачные для сложных задач.

OpenAI API через Ollama совместимый интерфейс

import openai

# Настройка для работы через Ollama
openai.api_base = "http://ollama:11434/v1"
openai.api_key = "ollama"  # не используется, но требуется

def hybrid_completion(prompt, use_cloud=False):
    if use_cloud:
        # Переключаемся на OpenAI
        openai.api_base = "https://api.openai.com/v1"
        openai.api_key = os.getenv("OPENAI_API_KEY")
        model = "gpt-4"
    else:
        # Локальная модель
        openai.api_base = "http://ollama:11434/v1"
        model = "llama3.1:8b"
    
    response = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.choices[0].message.content

Роутинг запросов по приоритету

class SmartRouter:
    def __init__(self):
        self.local_model = "qwen2.5:14b"
        self.cloud_model = "gpt-4-turbo"
    
    def classify_query(self, query):
        """Определяет сложность запроса"""
        complexity_keywords = [
            'анализ', 'сравни', 'объясни подробно',
            'стратегия', 'креатив', 'напиши статью'
        ]
        
        return any(kw in query.lower() for kw in complexity_keywords)
    
    def route(self, query, has_sensitive_data=True):
        is_complex = self.classify_query(query)
        
        # Конфиденциальные данные всегда локально
        if has_sensitive_data:
            return self.local_model, False
        
        # Сложные задачи в облако
        if is_complex:
            return self.cloud_model, True
        
        # Простые задачи локально
        return self.local_model, False

Мониторинг и логирование

Для production важен мониторинг работы системы.

Prometheus метрики для Ollama

from prometheus_client import Counter, Histogram, Gauge
import time

# Метрики
requests_total = Counter('ollama_requests_total', 'Total requests')
request_duration = Histogram('ollama_request_duration_seconds', 'Request duration')
active_requests = Gauge('ollama_active_requests', 'Active requests')
tokens_generated = Counter('ollama_tokens_generated_total', 'Total tokens')

class MonitoredOllama:
    def __init__(self):
        self.client = ollama.Client(host='http://ollama:11434')
    
    @request_duration.time()
    def generate(self, model, prompt):
        requests_total.inc()
        active_requests.inc()
        
        try:
            start = time.time()
            response = self.client.generate(model=model, prompt=prompt)
            
            # Считаем токены
            tokens = len(response['response'].split())
            tokens_generated.inc(tokens)
            
            return response
        finally:
            active_requests.dec()

Grafana dashboard

{
  "dashboard": {
    "title": "Ollama Monitoring",
    "panels": [
      {
        "title": "Requests per Second",
        "targets": [{
          "expr": "rate(ollama_requests_total[1m])"
        }]
      },
      {
        "title": "Average Response Time",
        "targets": [{
          "expr": "rate(ollama_request_duration_seconds_sum[5m]) / rate(ollama_request_duration_seconds_count[5m])"
        }]
      },
      {
        "title": "Tokens per Second",
        "targets": [{
          "expr": "rate(ollama_tokens_generated_total[1m])"
        }]
      }
    ]
  }
}

Безопасность и изоляция

Сетевая изоляция через Docker networks

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true  # без доступа в интернет

services:
  ollama:
    networks:
      - backend
  
  open-webui:
    networks:
      - frontend
      - backend
  
  caddy:
    networks:
      - frontend

Rate limiting через Caddy

webui.example.com {
    rate_limit {
        zone webui {
            key {remote_host}
            events 100
            window 1m
        }
    }
    
    reverse_proxy open-webui:8080
}

Аутентификация через OAuth2

services:
  oauth2-proxy:
    image: quay.io/oauth2-proxy/oauth2-proxy
    environment:
      OAUTH2_PROXY_CLIENT_ID: ${OAUTH_CLIENT_ID}
      OAUTH2_PROXY_CLIENT_SECRET: ${OAUTH_CLIENT_SECRET}
      OAUTH2_PROXY_COOKIE_SECRET: ${COOKIE_SECRET}
      OAUTH2_PROXY_UPSTREAMS: http://open-webui:8080
      OAUTH2_PROXY_EMAIL_DOMAINS: example.com

Подводные камни и их решения

Проблема 1: Out of Memory при загрузке больших моделей

Симптом: Container killed при ollama pull llama3.1:70b

Решение: Увеличить swap и настроить memory limits

services:
  ollama:
    deploy:
      resources:
        limits:
          memory: 32G
        reservations:
          memory: 16G

# Увеличить swap
sudo fallocate -l 32G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

Проблема 2: Медленная работа Qdrant при большом количестве документов

Симптом: Поиск занимает 5-10 секунд при 100k+ документов

Решение: Оптимизация индекса и использование quantization

from qdrant_client.models import QuantizationConfig, ScalarQuantization

self.qdrant.update_collection(
    collection_name="documents",
    quantization_config=ScalarQuantization(
        scalar=ScalarQuantizationConfig(
            type="int8",
            quantile=0.99,
            always_ram=True
        )
    )
)

Результат: поиск ускорился в 3-4 раза, использование RAM снизилось на 70%.

Проблема 3: Периодические падения N8N при большой нагрузке

Симптом: N8N container restart при одновременной обработке 50+ webhook

Решение: Настройка queue mode

services:
  n8n:
    environment:
      - EXECUTIONS_MODE=queue
      - QUEUE_BULL_REDIS_HOST=redis
      - QUEUE_HEALTH_CHECK_ACTIVE=true
  
  redis:
    image: redis:alpine
    command: redis-server --maxmemory 2gb --maxmemory-policy allkeys-lru

Сравнение качества: локальные vs облачные модели

Провел тестирование на наборе из 100 вопросов по техподдержке (real-world данные).

Метрики оценки

• Точность — процент правильных ответов (проверка человеком)

• Полнота — наличие всех важных деталей в ответе

• Релевантность — соответствие ответа вопросу

Результаты RAG задач

Выводы:

• Для RAG задач локальные модели 14B+ показывают приемлемое качество (78%+)

• Разница с GPT-4 в 10-15%, что для многих сценариев допустимо

• Модели 70B+ приближаются к качеству GPT-4, но требуют мощное железо

Whisper: распознавание речи

Проект использует faster-whisper-server — оптимизированный STT сервер.

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

API использование

# Транскрибация аудио
curl -X POST http://whisper:8000/v1/audio/transcriptions \
  -F "file=@audio.mp3" \
  -F "model=base"

# Response:
{
  "text": "Расшифрованный текст...",
  "language": "ru",
  "duration": 15.3
}

Интеграция в N8N

// N8N HTTP Request Node
{
  "method": "POST",
  "url": "http://whisper:8000/v1/audio/transcriptions",
  "bodyParameters": {
    "parameters": [
      {
        "name": "file",
        "value": "={{$binary.data}}"
      },
      {
        "name": "model",
        "value": "base"
      }
    ]
  }
}

Производительность

Base модель на Intel i7-12700K:

• Скорость: ~48x real-time

• 1 минута аудио = 1.25 секунды обработки

• RAM: 500-800 MB

Base модель на RTX 3060:

• Скорость: ~180x real-time

• 1 минута аудио = 0.33 секунды

• VRAM: 200-300 MB

Расчёт TCO (Total Cost of Ownership) — декабрь 2025

Вариант 1: Полностью облачное решение

GPT-4 Turbo:

Средний запрос: 1000 input + 500 output токенов
Стоимость: $0.01/1k input + $0.03/1k output = $0.025/запрос

1000 запросов/день:
$0.025 × 1000 × 30 = $750/месяц
$9000/год

Claude Sonnet 4.5:

Стоимость: $0.003/1k input + $0.015/1k output = $0.0105/запрос

1000 запросов/день:
$0.0105 × 1000 × 30 = $315/месяц
$3780/год

Вариант 2: Локальное решение

CPU-only (VPS 8 cores/16GB):

Аренда VPS в РФ: $50-80/месяц
Модель: Mistral 7B / Qwen 2.5 7B
Скорость: ~20 сек/ответ (приемлемо для асинхронных задач)

Итого: $60/месяц = $720/год
ROI vs GPT-4: окупается за 1 месяц при 1000+ запросов/день
ROI vs Claude: окупается за 5 месяцев

GPU сервер (RTX 3060 12GB):

Аренда в РФ: $150-200/месяц
Модель: Llama 3.1 8B / Qwen 2.5 Coder 14B
Скорость: 1-2 сек/ответ

Итого: $175/месяц = $2100/год
ROI vs GPT-4: окупается за 2-3 месяца
ROI vs Claude: окупается за 7 месяцев

Собственный сервер (RTX 4090 24GB):

Единоразовые затраты:
- Сервер (без GPU): $1500
- RTX 4090: $1600
- Итого: $3100

Ежемесячные расходы:
- Электричество (24/7): ~$60
- Интернет: $30
- Итого: $90/месяц = $1080/год

Полная стоимость владения (3 года):
$3100 + ($1080 × 3) = $6340
Или $176/месяц

Модель: Llama 3.3 70B / DeepSeek-R1 70B
Качество: близко к GPT-4

Вариант 3: Гибридный подход (оптимальный)

Локальный VPS + облачные API для сложных задач:

VPS (CPU, 16GB): $60/месяц
YandexGPT API (20% запросов): ~$50/месяц
или Claude API (5% запросов): ~$20/месяц

Итого: $80-110/месяц = $960-1320/год

Преимущества:
✅ Соответствие 152-ФЗ (большинство данных локально)
✅ Экономия на рутинных задачах
✅ Высокое качество на сложных запросах
✅ Масштабируемость

Сравнительная таблица (1000 запросов/день)

*После окупаемости оборудования (24-30 месяцев) только электричество ~$90/мес

Breakeven Analysis

При каком объёме запросов окупается собственное решение?

# GPT-4 Turbo vs RTX 4090 (собственный)
def calculate_breakeven(requests_per_day):
    # Затраты GPT-4
    gpt4_cost_per_month = requests_per_day * 30 * 0.025
    
    # Затраты собственный сервер
    initial_cost = 3100  # Оборудование
    monthly_cost = 90    # Электричество + интернет
    
    # Breakeven
    months = initial_cost / (gpt4_cost_per_month - monthly_cost)
    return months

# Примеры:
# 100 запросов/день: 18 месяцев
# 500 запросов/день: 5 месяцев
# 1000 запросов/день: 2.5 месяца
# 5000 запросов/день: <1 месяца

Вывод: При нагрузке 1000+ запросов/день собственная инфраструктура окупается за 2-3 месяца.

Масштабирование и отказоустойчивость

Horizontal scaling Ollama

services:
  ollama-1:
    image: ollama/ollama
    deploy:
      replicas: 3
  
  ollama-lb:
    image: nginx:alpine
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - ollama-1

upstream ollama_backend {
    least_conn;
    server ollama-1:11434;
    server ollama-2:11434;
    server ollama-3:11434;
}

server {
    listen 11434;
    location / {
        proxy_pass http://ollama_backend;
    }
}

Резервное копирование

#!/bin/bash
# backup.sh

BACKUP_DIR="/backups/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR

# Backup volumes
docker run --rm \
  -v ollama_data:/data \
  -v $BACKUP_DIR:/backup \
  alpine tar czf /backup/ollama_data.tar.gz /data

docker run --rm \
  -v qdrant_data:/data \
  -v $BACKUP_DIR:/backup \
  alpine tar czf /backup/qdrant_data.tar.gz /data

# Backup PostgreSQL
docker exec supabase-db pg_dump -U postgres > $BACKUP_DIR/postgres.sql

# Удаление старых бэкапов (>30 дней)
find /backups -type d -mtime +30 -exec rm -rf {} +

Заключение

Собрал работающее решение для локального запуска AI-инфраструктуры на базе проверенных open source проектов. Система используется в production у нескольких клиентов с нагрузкой до 10k запросов в день.

Ключевые достижения декабря 2025

Прорыв в качестве локальных моделей:

• DeepSeek-R1 70B достигает 86% точности в математике (GPT-4: 88%)

• Qwen 2.5 Coder 32B превосходит Claude Sonnet в задачах кодирования

• Llama 3.3 70B показывает 91% точность в RAG (GPT-4: 96%)

Экономическая целесообразность:

• При 1000+ запросов/день собственная инфраструктура окупается за 2-3 месяца

• Гибридный подход (локально + облако) экономит 80-90% vs чистое облако

• Качество локальных моделей достаточно для 90% бизнес-задач

Техническая зрелость:

• Полностью автоматизированная установка (CTAPT.py)

• Готовые production workflows

• Интеграция Open WebUI с N8N через Pipe Functions

• Мониторинг и логирование из коробки

Когда имеет смысл использовать

Обязательно локально:

• Обработка персональных данных (152-ФЗ строго)

• Конфиденциальная информация под NDA

• Государственные организации

• Медицинские данные

• Финансовая информация

Рекомендуется локально:

• Высокая интенсивность запросов (1000+ в день)

• Необходимость кастомизации и полного контроля

• Работа в изолированных сетях

• Предсказуемый бюджет (нет расходов на токены)

Облако лучше когда:

• Низкая интенсивность (<100 запросов/день)

• Критичны cutting-edge модели (GPT-4, Claude Opus)

• Нет технической экспертизы для поддержки

• Стартап на ранней стадии (быстрое MVP)

Практические рекомендации

Для RAG и техподдержки:

Стартовая: Gemma 3 1B на CPU (бесплатно)
Оптимальная: Llama 3.1 8B на RTX 3060 ($175/мес)
Премиум: Llama 3.3 70B на RTX 4090 (собственный)

Для программирования:

Стартовая: Qwen 2.5 Coder 7B на CPU
Оптимальная: Qwen 2.5 Coder 14B на RTX 3060
Премиум: Qwen 2.5 Coder 32B на RTX 4090

Для аналитики и reasoning:

Стартовая: DeepSeek-R1 7B на CPU
Оптимальная: DeepSeek-R1 14B на RTX 3060
Премиум: DeepSeek-R1 70B на RTX 4090

Что дальше

Проект активно развивается:

• Интеграция с российскими CRM (Битрикс24, AmoCRM)

• Поддержка новых моделей при релизе

• Оптимизация RAG (гибридный поиск, re-ranking)

• Расширенная аналитика и мониторинг

• Benchmark российских моделей (GigaChat, YandexGPT)

Благодарности

Проект создан на основе:

• n8n-io/self-hosted-ai-starter-kit

• coleam00/local-ai-packaged

• coleam00/ottomator-agents

Особая благодарность Cole Medin за первоначальную архитектуру и идеи.

Ссылки

• Репозиторий: github.com/shorin-nikita/lisa

• Документация: README.md в репозитории

• Ollama Models: ollama.com/library

• N8N Docs: docs.n8n.io

• Qdrant Docs: qdrant.tech/documentation

Дополнительные материалы

• Ollama GitHub — локальный LLM сервер

• Open WebUI — ChatGPT-подобный интерфейс

• Qdrant Documentation — векторная БД

• N8N Documentation — платформа автоматизации

• Supabase Docs — PostgreSQL + pgvector

• Faster Whisper — оптимизированный STT