ИИ и автоматизация 15 мин чтения 2026-11-08

Автономная команда ИИ-агентов в CrewAI на VDS: развертывание в Docker Compose с Ollama и веб-интерфейсом

Развертываем многоагентную систему (Multi-Agent System) на базе CrewAI v1.15, локальной Ollama и Redis на VDS в Docker Compose. Готовый FastAPI-сервер, защита Nginx, фоновые задачи и Telegram-уведомления.

Инженерная редакция SysKit Проверено инженерами SysKit.ru

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

Концепция мультиагентных систем (Multi-Agent Systems, MAS) переносит этот проверенный принцип разделения труда в мир ИИ. Вместо единого чат-бота запускается сплоченная команда узкоспециализированных агентов (Agents). Каждый агент имеет строгую роль (Role), измеримую цель (Goal), профессиональный бэкграунд (Backstory) и доступ только к необходимым инструментам (Tools). Агенты последовательно или иерархически передают промежуточные результаты друг другу, критикуют гипотезы коллег и доводят задачу до финала без вмешательства человека.

CrewAI — ведущий в мире open-source фреймворк для оркестрации ролевых команд ИИ-агентов (более 60 000 звёзд на GitHub, актуальный релиз v1.15.37). В отличие от избыточно сложных графовых конструкций (вроде LangGraph), CrewAI предлагает чистый, модульный и легковесный Python-стек, не зависящий от монолитных абстракций LangChain и идеально подходящий для автономного запуска на собственном VDS.

1. Архитектура мультиагентной команды под капотом

Рассмотрим боевой сценарий: автономный конвейер подготовки глубокого отчёта по миграции IT-инфраструктуры или анализу конкурентов. Команда состоит из трех специализированных агентов:

  1. Старший исследователь (Senior Market Researcher): исследует заданную тему, собирает ключевые технические спецификации, выявляет рыночные тренды и фиксирует подтвержденные факты.
  2. Технический аналитик (Tech Strategy Analyst): получает отчет исследователя, проводит SWOT-анализ, сопоставляет альтернативы, рассчитывает ориентировочные затраты на VDS/лицензии и формулирует риски внедрения.
  3. Шеф-редактор (Chief Technology Writer): берет аналитическую записку и формирует финальный документ в формате Markdown с понятными таблицами, инженерными выводами и пошаговым чек-листом.
Контейнер / Сервис Базовый образ / Стек Сетевой порт Роль в инфраструктуре мультиагентов
crewai-api Python 3.11 / FastAPI / crewai 1.15.37 127.0.0.1:8000 Основной API-шлюз оркестрации. Принимает задачи через REST API, запускает конвейер экипажа (Crew) в асинхронных фоновых процессах и сохраняет статус выполнения.
ollama ollama/ollama:0.40.15 127.0.0.1:11434 Локальный инференс-сервер. Обеспечивает выполнение рассуждений агентов на квантованных моделях (например, qwen2.5:7b или qwen2.5:3b) без передачи данных во внешние облака.
redis redis:7.4-alpine 127.0.0.1:6379 Брокер сообщений и оперативное хранилище состояний задач. Хранит очередь и статусы выполнения пайплайнов (queued, running, completed, failed), а также готовые Markdown-отчёты с автоматическим TTL-очищением.
nginx Nginx 1.24+ (системный на хосте) 80, 443 Reverse Proxy с Let's Encrypt SSL. Терминирует защищенный трафик, проверяет Bearer-токены авторизации и удерживает длительные HTTP-таймауты для долгих аналитических сессий.

Все сервисы изолированы в общей внутренней Docker-сети crewai-net, а их сетевые порты на хосте привязаны строго к 127.0.0.1, что полностью исключает доступ к API и Ollama из внешней сети в обход системного фаервола.

2. Системные требования и выбор тарифа VDS

В отличие от простого чат-бота, мультиагентная система запускает несколько последовательных раундов рассуждений (Reasoning Chains), в которых агенты анализируют данные, формулируют промежуточные выводы и передают их коллегам. Требования к ресурсам зависят от выбранного режима инференса:

Режим работы vCPU RAM Диск (NVMe) Назначение и сценарий использования
Гибридный (CrewAI + Redis на VDS, внешнее API DeepSeek/OpenRouter) 1–2 ядра (от 3.0 ГГц) 2 ГБ – 4 ГБ 20 ГБ Оркестрация агентов, веб-интерфейс, очереди задач и отчёты хранятся локально на сервере. Сами вызовы LLM отправляются через API. Минимальная стоимость аренды VDS (от 350 ₽/мес).
100% Автономный On-Premise (CrewAI + локальная Ollama на CPU) 4 ядра (высокочастотные 3.3+ ГГц) 8 ГБ – 16 ГБ 40–60 ГБ Полная независимость и изоляция коммерческих данных. Модель qwen2.5:3b (для 8 ГБ RAM) или qwen2.5:7b (для 16 ГБ RAM) выполняется полностью локально на CPU сервера.

Почему для локального CPU-инференса выбрана модель Qwen 2.5 3B? Флагманские тяжелые модели (например, серия Qwen3 от 30B параметров или Llama 3.3 70B) требуют от 24–32 ГБ RAM и дискретных GPU, что делает их развертывание недоступным на недорогих тарифах VDS. В то же время квантованная инструктивная модель qwen2.5:3b (в квантовании Q4_K_M) занимает всего ~1.9 ГБ на диске и ~2.2 ГБ RAM, выдавая скорость 20–25 токенов/сек на стандартном 4-ядерном CPU VDS (от 3.3 ГГц). Это оптимальный баланс качества аналитических цепочек и минимального бюджета сервера (от 1200 ₽/мес).

🔒 Конфиденциальность коммерческих данных компании

При подготовке стратегических отчетов, анализе закрытых баз данных клиентов или планировании финансовых бюджетов передача промптов в сторонние зарубежные облака несет риск утечки коммерческой тайны. Развертывание суверенного стека CrewAI и Ollama на серверах российских хостинг-провайдеров гарантирует, что интеллектуальная собственность и корпоративные данные остаются строго внутри контролируемого контура.

3. Подготовка сервера и конфигурация стека Docker Compose

Создадим рабочую директорию проекта /opt/crewai-stack/ с изолированными каталогами для кода API, скриптов автоматизации и персистентных данных Ollama и Redis:

sudo mkdir -p /opt/crewai-stack/{server,ollama_data,redis_data,scripts}
cd /opt/crewai-stack

Создадим микросервис оркестрации server/main.py на базе FastAPI. Для небольших команд и внутренних сервисов связка FastAPI BackgroundTasks с Redis для хранения статусов является оптимальным и легковесным решением без утяжеления стека брокерами вроде Celery или RabbitMQ (архитектуру для высоконагруженных мульти-тенант систем мы детально разберем в FAQ). В коде инициализируются три агента с жестко заданным лимитом шагов max_iter=5, отключается фоновая телеметрия фреймворка, а выполнение конвейера запускается асинхронно:

# /opt/crewai-stack/server/main.py
import os

# Отключение телеметрии до импорта модулей CrewAI (суверенный контур 152-ФЗ)
os.environ["CREWAI_DISABLE_TELEMETRY"] = "true"
os.environ["OTEL_SDK_DISABLED"] = "true"

import uuid
import json
import secrets
from typing import Optional
from contextlib import asynccontextmanager
import redis
from fastapi import FastAPI, HTTPException, Security, BackgroundTasks, Depends
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel
from crewai import Agent, Task, Crew, Process, LLM
from crewai.tools import tool

API_BEARER_TOKEN = os.getenv("API_BEARER_TOKEN")
if not API_BEARER_TOKEN:
    raise RuntimeError("Критическая ошибка: переменная окружения API_BEARER_TOKEN не задана в .env!")

REDIS_HOST = os.getenv("REDIS_HOST", "redis")
REDIS_PORT = int(os.getenv("REDIS_PORT", "6379"))
OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://ollama:11434")
LLM_MODEL = os.getenv("LLM_MODEL", "ollama/qwen2.5:3b")

r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, db=0, decode_responses=True)

@asynccontextmanager
async def lifespan(app: FastAPI):
    """Сброс зависших задач при перезапуске контейнера"""
    try:
        for key in r.scan_iter("crew:*:status"):
            if r.get(key) in ("running", "queued"):
                r.set(key, "failed", ex=604800)
                task_id = key.split(":")[1]
                r.set(f"crew:{task_id}:error", "Выполнение прервано: контейнер был перезапущен", ex=604800)
    except Exception as e:
        print(f"Ошибка проверки незавершенных задач: {e}")
    yield

app = FastAPI(title="SysKit CrewAI Orchestration Service", version="1.15.37", lifespan=lifespan)
security = HTTPBearer()

def verify_token(credentials: HTTPAuthorizationCredentials = Security(security)):
    if not secrets.compare_digest(credentials.credentials, API_BEARER_TOKEN):
        raise HTTPException(status_code=401, detail="Недействительный токен авторизации")
    return credentials.credentials

@tool("Сбор фактов и мониторинг источников")
def search_corporate_data(query: str) -> str:
    """Инструмент поиска актуальной технической информации, тарифов VDS и документации в веб-источниках или корпоративном RAG."""
    # В production здесь вызывается локальный поисковый шлюз (SearXNG), DuckDuckGo или ScrapeWebsiteTool из crewai-tools
    return (
        f"[Фактические данные мониторинга по запросу: '{query}']\n"
        "- Timeweb Cloud: конфигурация 4 vCPU 3.3 ГГц, 8 ГБ RAM, 60 ГБ NVMe — ~1490 ₽/мес, ЦОД Санкт-Петербург и Москва, SLA 99.98%.\n"
        "- Selectel: сервер 4 vCPU, 8 ГБ RAM, 80 ГБ NVMe — ~2250 ₽/мес, ЦОД уровня Tier III (152-ФЗ, УЗ-1), сетевой API, почасовая оплата.\n"
        "- Защита данных: обе платформы обеспечивают локализацию серверов в РФ согласно 152-ФЗ и работу без зарубежных карт."
    )

class CrewRequest(BaseModel):
    topic: str
    custom_instructions: Optional[str] = None

def run_crew_pipeline(task_id: str, topic: str, custom_instructions: Optional[str] = None):
    try:
        r.set(f"crew:{task_id}:status", "running", ex=604800)
        
        # Настройка единого LLM провайдера для всей команды
        ollama_llm = LLM(
            model=LLM_MODEL,
            base_url=OLLAMA_BASE_URL,
            temperature=0.2
        )

        # 1. Агент-исследователь с инструментом сбора фактов
        researcher = Agent(
            role="Старший технический исследователь",
            goal=f"Собрать исчерпывающие и объективные факты по теме: {topic}",
            backstory="Опытный системный архитектор и аналитик, умеющий находить подтвержденные факты, бенчмарки и технические детали без лишней воды.",
            llm=ollama_llm,
            tools=[search_corporate_data],
            max_iter=5,
            verbose=False
        )

        # 2. Агент-аналитик
        analyst = Agent(
            role="Стратегический IT-аналитик",
            goal="Оценить риски, преимущества, стоимость владения и возможные подводные камни выявленных решений",
            backstory="Практикующий DevOps-консультант и технический аудитор с 15-летним стажем, мыслящий категориями отказоустойчивости и ROI.",
            llm=ollama_llm,
            max_iter=5,
            verbose=False
        )

        # 3. Шеф-редактор
        writer = Agent(
            role="Главный технический редактор",
            goal="Синтезировать аналитические материалы в безупречный структурированный отчёт в формате Markdown",
            backstory="Инженерный редактор издания SysKit. Пишет строго по делу, использует четкие заголовки, списки и практические рекомендации.",
            llm=ollama_llm,
            max_iter=5,
            verbose=False
        )

        # Задачи конвейера
        task_research = Task(
            description=f"Проведи глубокое исследование по теме: '{topic}'. Выдели ключевые технологии, архитектурные особенности и актуальные тренды на сегодня.",
            expected_output="Структурированный перечень фактов, характеристик и ссылок на стандарты.",
            agent=researcher
        )

        task_analysis = Task(
            description="Изучи факты, собранные исследователем. Проведи сравнительный анализ, выдели плюсы и минусы, риски безопасности и оценку затрат на серверную инфраструктуру.",
            expected_output="Аналитическая записка со сравнительной таблицей и оценкой рисков.",
            agent=analyst,
            context=[task_research]
        )

        task_writing = Task(
            description=f"На основе исследования и аналитической записки сформируй итоговый отчет для руководства по теме '{topic}'. Добавь практический чек-лист внедрения." + (f" Дополнительные требования: {custom_instructions}" if custom_instructions else ""),
            expected_output="Финальный готовый документ в Markdown с заголовками H2/H3, списками и практическими выводами.",
            agent=writer,
            context=[task_research, task_analysis]
        )

        crew = Crew(
            agents=[researcher, analyst, writer],
            tasks=[task_research, task_analysis, task_writing],
            process=Process.sequential,
            verbose=False
        )

        result = crew.kickoff()
        r.set(f"crew:{task_id}:result", str(result), ex=604800)
        r.set(f"crew:{task_id}:status", "completed", ex=604800)
    except Exception as e:
        r.set(f"crew:{task_id}:status", "failed", ex=604800)
        r.set(f"crew:{task_id}:error", str(e), ex=604800)

@app.post("/api/v1/crews/research", dependencies=[Depends(verify_token)])
def create_research_task(req: CrewRequest, background_tasks: BackgroundTasks):
    task_id = str(uuid.uuid4())
    r.set(f"crew:{task_id}:status", "queued", ex=604800)
    r.set(f"crew:{task_id}:topic", req.topic, ex=604800)
    
    background_tasks.add_task(run_crew_pipeline, task_id, req.topic, req.custom_instructions)
    return {
        "status": "queued",
        "task_id": task_id,
        "message": f"Конвейер исследования запущен для темы: '{req.topic}'"
    }

@app.get("/api/v1/crews/{task_id}", dependencies=[Depends(verify_token)])
def get_task_status(task_id: str):
    status = r.get(f"crew:{task_id}:status")
    if not status:
        raise HTTPException(status_code=404, detail="Задача не найдена")
    
    response = {"task_id": task_id, "status": status}
    if status == "completed":
        response["result"] = r.get(f"crew:{task_id}:result")
    elif status == "failed":
        response["error"] = r.get(f"crew:{task_id}:error")
    return response

@app.get("/health")
def healthcheck():
    return {"status": "ok", "service": "crewai-multi-agent-system", "version": "1.15.37"}

Создадим легковесный и безопасный server/Dockerfile:

# /opt/crewai-stack/server/Dockerfile
FROM python:3.11-slim

WORKDIR /app
ENV PYTHONUNBUFFERED=1

RUN pip install --no-cache-dir \
    fastapi==0.115.6 \
    uvicorn==0.34.0 \
    pydantic==2.10.4 \
    redis==5.2.1 \
    crewai==1.15.37 \
    crewai-tools==1.15.37

COPY main.py /app/main.py

USER 1000:1000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Сформируем файл переменных окружения /opt/crewai-stack/.env. Для генерации безопасного токена воспользуйтесь генератором надежных паролей SysKit:

# Обязательно сгенерируйте собственный криптостойкий токен через генератор SysKit
API_BEARER_TOKEN=sk_live_vds_prod_your_unique_secret_token_here
REDIS_HOST=redis
REDIS_PORT=6379
OLLAMA_BASE_URL=http://ollama:11434
LLM_MODEL=ollama/qwen2.5:3b

# Полное отключение исходящей телеметрии фреймворка (суверенный контур 152-ФЗ)
CREWAI_DISABLE_TELEMETRY=true
OTEL_SDK_DISABLED=true

Теперь создадим основной манифест docker-compose.yml. Мы строго соблюдаем production-стандарты: зафиксированные стабильные версии образов, директивы mem_limit и cpus для защиты от Linux OOM Killer, изолированная Docker-сеть и привязка портов строго к 127.0.0.1 для исключения обхода UFW. Для проверки жизнеспособности контейнера Ollama используется нативная встроенная команда ollama list (так как в официальном образе утилита curl отсутствует):

# /opt/crewai-stack/docker-compose.yml
services:
  redis:
    image: redis:7.4-alpine
    container_name: crewai_redis
    restart: unless-stopped
    ports:
      - "127.0.0.1:6379:6379"
    volumes:
      - ./redis_data:/data
    mem_limit: 512m
    cpus: 1.0
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - crewai-net

  ollama:
    image: ollama/ollama:0.40.15
    container_name: crewai_ollama
    restart: unless-stopped
    ports:
      - "127.0.0.1:11434:11434"
    volumes:
      - ./ollama_data:/root/.ollama
    mem_limit: 4096m
    cpus: 3.5
    healthcheck:
      test: ["CMD", "ollama", "list"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - crewai-net

  crewai-api:
    build:
      context: ./server
      dockerfile: Dockerfile
    container_name: crewai_api
    restart: unless-stopped
    ports:
      - "127.0.0.1:8000:8000"
    env_file:
      - .env
    depends_on:
      redis:
        condition: service_healthy
      ollama:
        condition: service_healthy
    mem_limit: 1536m
    cpus: 1.5
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health')"]
      interval: 15s
      timeout: 5s
      retries: 3
      start_period: 15s
    networks:
      - crewai-net

networks:
  crewai-net:
    driver: bridge

4. Запуск стека и загрузка моделей

Соберем контейнер API и запустим стек в фоновом режиме:

sudo docker compose up -d --build
sudo docker compose ps

После успешного старта контейнеров загрузим в Ollama модель qwen2.5:3b (или qwen2.5:7b при наличии 16 ГБ RAM):

sudo docker exec -it crewai_ollama ollama pull qwen2.5:3b

Проверим работоспособность эндпоинта проверки здоровья:

curl -s http://127.0.0.1:8000/health
# Ожидаемый ответ: {"status":"ok","service":"crewai-multi-agent-system","version":"1.15.37"}

Рекомендуемые VDS-провайдеры

Отказоустойчивые сервера с быстрыми NVMe и каналом до 1 Гбит/с

Выбор редакции
⚡

Timeweb Cloud — Быстрые NVMe VDS

Высокочастотные процессоры 3.3+ ГГц для быстрого инференса локальных моделей в Ollama, скоростные NVMe-накопители и канал 1 Гбит/с.

Конфигурация
4 vCPU 3.3 ГГц • 8 ГБ RAM • 60 ГБ NVMe • Трафик без лимита
Премиум Tier III
🔷

Selectel — Надежные облачные серверы

Аттестованная инфраструктура в ЦОД уровня Tier III в РФ. Идеально для корпоративных задач и соблюдения требований 152-ФЗ.

Конфигурация
4 vCPU • 8 ГБ RAM • 80 ГБ NVMe • ЦОД Tier III 152-ФЗ
Простота и надежность
🟠

Beget — Удобные VDS для разработчиков

Интуитивная панель управления, автоматические ежедневные бэкапы хоста и мгновенное развертывание Docker за 1 клик.

Конфигурация
4 vCPU • 8 ГБ RAM • 50 ГБ NVMe • Безлимитный канал

5. Настройка безопасного Nginx Reverse Proxy и SSL

Так как агенты CrewAI выполняют глубокий последовательный анализ, генерация ответа может занимать от 30 секунд до 2–3 минут в зависимости от сложности темы и скорости CPU. Стандартные таймауты Nginx (60 секунд) приведут к ошибке 504 Gateway Timeout. Настроим системный Nginx с бесплатным SSL-сертификатом Let's Encrypt и расширенными таймаутами ожидания.

Установим Certbot и выпустим сертификат для вашего поддомена (например, crewai.yourdomain.ru):

sudo apt update && sudo apt install -y nginx certbot python3-certbot-nginx

# Выпуск сертификата Let's Encrypt
sudo certbot certonly --nginx -d crewai.yourdomain.ru --agree-tos --email admin@yourdomain.ru --no-eff-email

Создадим виртуальный хост Nginx /etc/nginx/sites-available/crewai.conf:

# Ограничение частоты запросов: до 10 запросов в секунду с одного IP
limit_req_zone $binary_remote_addr zone=crewai_rate:10m rate=10r/s;

upstream crewai_backend {
    server 127.0.0.1:8000;
    keepalive 32;
}

# Редирект HTTP -> HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name crewai.yourdomain.ru;

    location / {
        return 301 https://$host$request_uri;
    }
}

# Основной HTTPS сервер
server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name crewai.yourdomain.ru;

    ssl_certificate /etc/letsencrypt/live/crewai.yourdomain.ru/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/crewai.yourdomain.ru/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1d;

    client_max_body_size 32M;

    location / {
        limit_req zone=crewai_rate burst=15 nodelay;
        limit_req_status 429;

        proxy_pass http://crewai_backend;
        proxy_http_version 1.1;
        proxy_set_header Connection "";

        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Увеличенные таймауты под многораундовые рассуждения агентов CrewAI
        proxy_connect_timeout 90s;
        proxy_send_timeout 600s;
        proxy_read_timeout 600s;
    }
}

Активируем конфигурацию, проверяем синтаксис и перезагружаем веб-сервер:

sudo ln -s /etc/nginx/sites-available/crewai.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Для создания кастомных конфигураций воспользуйтесь генератором Nginx для FastAPI/Uvicorn, а проверить корректность цепочки сертификата — через SSL-чекер SysKit.

6. Тестирование мультиагентного конвейера через REST API

Запустим исследование практической инженерной темы через curl, передав авторизационный заголовок Authorization: Bearer:

curl -X POST https://crewai.yourdomain.ru/api/v1/crews/research \
  -H "Authorization: Bearer ВАШ_ТОКЕН_ИЗ_ENV" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "Сравнение российских облачных платформ Timeweb Cloud и Selectel для развертывания Docker Compose и локальных LLM",
    "custom_instructions": "Сделай акцент на стоимости за vCPU/RAM, наличии сертифицированных ЦОД по 152-ФЗ и удобстве сетевого API."
  }'

Сервис мгновенно вернет ответ с идентификатором задачи:

{
  "status": "queued",
  "task_id": "c4b12398-e74f-4d32-9a1c-8b5d3a9871f2",
  "message": "Конвейер исследования запущен для темы: 'Сравнение российских облачных платформ Timeweb Cloud и Selectel...'"
}

Проверим статус выполнения задачи:

curl -s https://crewai.yourdomain.ru/api/v1/crews/c4b12398-e74f-4d32-9a1c-8b5d3a9871f2 \
  -H "Authorization: Bearer ВАШ_ТОКЕН_ИЗ_ENV"

Пока конвейер работает, статус будет равен running. Как только третий агент (Шеф-редактор) завершит полировку текста, поле status перейдет в completed, а в поле result появится структурированный отчет в Markdown:

📋 Пример готового отчета, синтезированного агентами

Результат работы конвейера:

  • Старший исследователь: собрал актуальные тарифные линейки (NVMe-диски, частота процессоров 3.3+ ГГц, аплинки 1 Гбит/с) и подтвердил наличие сертификатов ФСТЭК/152-ФЗ.
  • Стратегический аналитик: сопоставил затраты — выделил экономичность Timeweb Cloud для малого/среднего бизнеса и высокую зрелость частных облаков Selectel для Enterprise-сегмента.
  • Шеф-редактор: объединил факты в четкую сводку с итоговой таблицей характеристик и пошаговым чек-листом миграции.

7. Автоматизация и периодические брифинги в Telegram

Автономная ценность многоагентной системы раскрывается в полной мере, когда агенты работают не только по разовому нажатию кнопки в браузере или Postman, а выполняют регулярный аналитический мониторинг по расписанию: сбор трендов, мониторинг конкурентов или подготовку утреннего Executive Summary для руководства и отправку готового Markdown-отчета в закрытый Telegram-канал или чат команды.

Для периодического вызова нашего API создадим легковесный скрипт на Python /opt/crewai-stack/scripts/send_briefing.py, который инициирует задачу исследования, ожидает формирования отчета через опрос статуса задачи и публикует результат в Telegram. Для генерации безопасных токенов и паролей вы можете использовать утилиту генератор криптостойких паролей SysKit.

#!/usr/bin/env python3
"""
Скрипт автономного запуска исследования CrewAI и отправки отчета в Telegram.
Путь: /opt/crewai-stack/scripts/send_briefing.py
"""
import os
import sys
import time
import requests

API_BASE_URL = os.getenv("CREWAI_API_URL", "http://127.0.0.1:8000")
API_KEY = os.getenv("API_BEARER_TOKEN", os.getenv("CREWAI_API_KEY", ""))
TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "")
TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "")

RESEARCH_TOPIC = "Ключевые тренды рынка AI-агентов и локальных LLM за неделю: фокус на корпоративную безопасность"

def trigger_crew() -> str:
    """Запуск фонового пайплайна агентов через FastAPI"""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    payload = {"topic": RESEARCH_TOPIC}
    resp = requests.post(f"{API_BASE_URL}/api/v1/crews/research", json=payload, headers=headers, timeout=15)
    resp.raise_for_status()
    data = resp.json()
    task_id = data.get("task_id")
    print(f"[INFO] Исследование запущено, Task ID: {task_id}")
    return task_id

def wait_for_completion(task_id: str, max_wait_seconds: int = 900) -> str:
    """Опрос статуса выполнения с интервалом 5 секунд"""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    start_time = time.time()
    
    while time.time() - start_time < max_wait_seconds:
        resp = requests.get(f"{API_BASE_URL}/api/v1/crews/{task_id}", headers=headers, timeout=10)
        if resp.status_code == 200:
            result = resp.json()
            status = result.get("status")
            if status == "completed":
                print("[INFO] Агенты успешно завершили работу!")
                return result.get("result", "")
            elif status == "failed":
                err = result.get("error", "Неизвестная ошибка")
                raise RuntimeError(f"Сбой выполнения агентов: {err}")
            else:
                print(f"[POLL] Статус: {status}... Ожидание 5 сек.")
        time.sleep(5)
    raise TimeoutError("Превышен таймаут ожидания аналитического отчета")

def send_to_telegram(text: str):
    """Отправка отчета в Telegram-чат с разбиением на блоки до 4000 символов"""
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
    
    # Ограничение Telegram на размер одного сообщения — 4096 символов
    chunk_size = 3900
    for i in range(0, len(text), chunk_size):
        chunk = text[i:i + chunk_size]
        payload = {
            "chat_id": TELEGRAM_CHAT_ID,
            "text": chunk,
            "parse_mode": "Markdown",
            "disable_web_page_preview": True
        }
        try:
            res = requests.post(url, json=payload, timeout=20)
            res.raise_for_status()
        except requests.HTTPError:
            # Fallback на plain text без форматирования, если LLM выдал невалидный Markdown
            payload.pop("parse_mode", None)
            res = requests.post(url, json=payload, timeout=20)
            res.raise_for_status()
        time.sleep(1)
    print("[SUCCESS] Отчет успешно доставлен в Telegram!")

if __name__ == "__main__":
    if not API_KEY or not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
        print("[ERROR] Не заполнены переменные окружения API_BEARER_TOKEN, TELEGRAM_BOT_TOKEN или TELEGRAM_CHAT_ID", file=sys.stderr)
        sys.exit(1)
    try:
        tid = trigger_crew()
        report = wait_for_completion(tid)
        header = f"📊 *Еженедельный аналитический дайджест CrewAI*\nТема: _{RESEARCH_TOPIC}_\n\n"
        send_to_telegram(header + report)
    except Exception as e:
        print(f"[FATAL] Ошибка сценария: {e}", file=sys.stderr)
        sys.exit(1)

Для регулярного выполнения по понедельникам в 09:00 утра настроим стандартный cron. Вы можете рассчитать и проверить расписание через онлайн-инструмент генератор Bash-скриптов бэкапа SysKit и службу конфигуратор systemd для Python-сервисов. Создадим файл задания /etc/cron.d/crewai-briefing с правами 0644:

# /etc/cron.d/crewai-briefing
# Запуск команды агентов каждый понедельник в 09:00 утра
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

0 9 * * 1 root set -a; . /opt/crewai-stack/.env; set +a && /usr/bin/python3 /opt/crewai-stack/scripts/send_briefing.py >> /var/log/crewai-briefing.log 2>&1

Установите корректные права на файл cron, иначе демон cron проигнорирует задание из соображений безопасности:

sudo chmod 0644 /etc/cron.d/crewai-briefing
sudo chown root:root /etc/cron.d/crewai-briefing

8. Резервное копирование и регламент обслуживания VDS

Хотя основная логика работы агентов сосредоточена в коде и моделях Ollama, в production-контуре необходимо регулярно создавать резервные копии:

  • Файлы конфигурации и окружения: docker-compose.yml, .env со всеми секретными токенами, исходный код агентов и кастомных промптов в папке server/.
  • Состояние Redis: если вы используете кэширование результатов исследований или сохраняете историю завершенных задач в постоянный том (AOF/RDB).
  • Nginx-конфигурация: виртуальный хост с настройками upstream и SSL-сертификаты Certbot.

Создадим автоматический bash-скрипт резервного копирования /usr/local/bin/backup-crewai.sh:

#!/usr/bin/env bash
# /usr/local/bin/backup-crewai.sh
# Скрипт холодного/горячего бэкапа конфигурации CrewAI Stack
set -euo pipefail

BACKUP_DIR="/var/backups/crewai"
DATE=$(date +"%Y%m%d_%H%M%S")
TARGET_ARCHIVE="${BACKUP_DIR}/crewai_backup_${DATE}.tar.gz"
RETENTION_DAYS=14

mkdir -p "${BACKUP_DIR}"
chmod 0700 "${BACKUP_DIR}"

echo "[INFO] [$(date)] Инициализация резервного копирования CrewAI..."

# 1. Принудительный сброс данных Redis на диск (SAVE)
if docker ps --format '{{.Names}}' | grep -q 'crewai_redis'; then
    echo "[INFO] Синхронизация Redis DB на диск..."
    docker exec crewai_redis redis-cli SAVE || true
fi

# 2. Упаковка конфигурации, скриптов и дампа Redis
tar -czf "${TARGET_ARCHIVE}" -C / \
    opt/crewai-stack/docker-compose.yml \
    opt/crewai-stack/.env \
    opt/crewai-stack/server \
    opt/crewai-stack/scripts \
    opt/crewai-stack/redis_data \
    etc/nginx/sites-available/crewai.conf

# Ограничиваем права доступа к архиву с секретными ключами
chmod 0600 "${TARGET_ARCHIVE}"

# 3. Ротация устаревших копий старше 14 дней
find "${BACKUP_DIR}" -type f -name "crewai_backup_*.tar.gz" -mtime +${RETENTION_DAYS} -delete

echo "[SUCCESS] [$(date)] Бэкап успешно создан: ${TARGET_ARCHIVE} ($(du -h "${TARGET_ARCHIVE}" | cut -f1))"

Обратите внимание, что мы намеренно исключили папку /opt/crewai-stack/ollama_data/models из ежедневного архива. Веса моделей весят от 2 до 5 гигабайт и являются неизменяемыми: при переносе на новый сервер их всегда быстрее повторно скачать командой docker exec -it crewai_ollama ollama pull qwen2.5:3b, чем ежедневно забивать диск и сетевой канал тяжелыми архивами.

Делаем скрипт исполняемым и настраиваем запуск в cron раз в сутки в 03:30 ночи:

sudo chmod 0700 /usr/local/bin/backup-crewai.sh
sudo chown root:root /usr/local/bin/backup-crewai.sh

# Добавляем в cron
echo "30 3 * * * root /usr/local/bin/backup-crewai.sh >> /var/log/crewai-backup.log 2>&1" | sudo tee /etc/cron.d/crewai-backup
sudo chmod 0644 /etc/cron.d/crewai-backup

9. Чек-лист готовности к Production и масштабирование

Перед переводом многоагентной системы в постоянную боевую эксплуатацию сверьтесь с проверочным чек-листом инженеров SysKit:

Компонент Параметр / Требование Статус / Рекомендация
Сетевая изоляция Внутренние порты Docker Порты 8000 (API), 11434 (Ollama), 6379 (Redis) привязаны строго к 127.0.0.1 и не торчат наружу.
Лимиты памяти Директивы mem_limit Для контейнеров заданы жесткие лимиты памяти в Compose, исключающие аварийное падение ядра Linux через OOM Killer.
Nginx Reverse Proxy Таймауты proxy_read_timeout Установлены значения не менее 300s для предотвращения ошибок 504 Gateway Timeout при глубоком рекурсивном рассуждении.
Защита от циклов Параметр max_iter В объектах Agent жестко зафиксирован лимит итераций (например, max_iter=5), что предотвращает зацикливание агентов.
Бэкапы и ключи Автоматическая ротация Настроен скрипт backup-crewai.sh с правами 0600 на архивы и очисткой старых копий старше 14 дней.

Если в процессе развития проекта объем аналитических задач вырастет, архитектура легко масштабируется: вы можете перенести контейнер ollama на отдельный сервер с дискретной видеокартой (GPU) или подключить коммерческие внешние LLM, не меняя код агентов и структуру пайплайна в CrewAI.

Также ознакомьтесь с материалами нашей редакции по смежным темам: настройка долгосрочной памяти AI-агентов в Mem0 и Qdrant и развертывание визуальных workflow и AI-агентов в Dify на VDS.

Вопросы и ответы (FAQ)

Популярные вопросы вебмастеров и сисадминов по данной теме

Чем CrewAI отличается от LangGraph и AutoGen для прикладных задач?
CrewAI ориентирован на четкую ролевую модель (Role-Playing Agents) с понятным разделением ролей, целей и бэкстори (Role, Goal, Backstory), что делает его идеальным для бизнес-пайплайнов (исследования, аудит, генерация отчетов). LangGraph предлагает низкоуровневый графовый контроль с циклическими состояниями, что требует больше кода для простых сценариев. AutoGen от Microsoft исторически фокусировался на свободном чате между агентами (GroupChat), что нередко приводило к избыточным токенам и непредсказуемым петлям рассуждения. В CrewAI версии 1.15+ структурированный поток Process.sequential или Process.hierarchical обеспечивает предсказуемый результат и минимальный расход ресурсов.
Как предотвратить бесконечные циклы рассуждения агентов и экономить токены?
Главный инструмент контроля в CrewAI — параметр max_iter при создании агента (например, max_iter=5). Он жестко ограничивает число итераций рассуждения и вызова инструментов. Кроме того, установите max_execution_time=180 (в секундах), verbose=False для production, и точно формулируйте поле expected_output у задач (Task). Когда ожидаемый результат сформулирован однозначно, агент-исполнитель прекращает размышления сразу после получения нужных фактов.
Можно ли запускать CrewAI полностью на CPU без дискретной видеокарты (GPU)?
Да. При использовании квантованных моделей (например, qwen2.5:3b-instruct или llama3.2:3b в Ollama с квантованием Q4_K_M) инференс на современном 4-ядерном процессоре VDS (Xeon Gold или AMD EPYC от 3.0 ГГц) выдает в среднем 15–20 токенов в секунду (в зависимости от частоты ядер процессора хоста). Полный цикл работы цепочки из 3 агентов занимает от 45 до 90 секунд, что полностью укладывается в рамки фоновых аналитических задач и пакетной генерации контента.
Как подключить собственные Python-инструменты и парсеры к агентам CrewAI?
В CrewAI создание кастомных инструментов реализуется через наследование от crewai.tools.BaseTool либо с помощью декоратора @tool. Вы можете обернуть вызовы внутренних корпоративных баз данных (PostgreSQL, ClickHouse), корпоративных API или локальных парсеров. Входные параметры строго типизируются через Pydantic-схему args_schema, благодаря чему LLM безошибочно передает аргументы в вашу функцию.
Безопасно ли хранить конфиденциальные коммерческие данные в такой системе?
Полностью безопасно. В предложенной архитектуре все компоненты (Ollama, Redis, FastAPI-сервер) изолированы внутри приватной Docker-сети 127.0.0.1 на сервере в российском ЦОД (Timeweb Cloud, Selectel или Beget). Кроме того, через переменные CREWAI_DISABLE_TELEMETRY=true и OTEL_SDK_DISABLED=true полностью заблокирована отправка анонимной аналитики OpenTelemetry во внешние сети. Ваши запросы, промпты и внутренние документы не покидают сервер, что гарантирует соблюдение требований 152-ФЗ о защите персональных данных и исключает утечку коммерческой тайны.
Подходит ли FastAPI BackgroundTasks для высокой нагрузки или необходим Celery?
Для небольших команд, внутренних ботов и периодических аналитических брифингов (1–2 параллельные задачи) связка FastAPI BackgroundTasks с сохранением статуса в Redis идеальна: она не требует лишних контейнеров и минимально нагружает сервер. Однако для масштабного multi-tenant production с десятками одновременных пользователей длительный вызов crew.kickoff() исчерпает пул потоков Uvicorn. В таких сценариях инженеры SysKit рекомендуют выносить выполнение агентов в распределенную очередь задач на базе Celery, RQ или Arq с отдельным контейнером-воркером, подключенным к Redis.

Читайте также в блоге SysKit

Смежные руководства и полезные технические статьи