CrewAI: установка и создание multi-agent системы

CrewAI — это open-source фреймворк для оркестрации multi-agent систем на Python, который полностью переписан с нуля и не зависит от LangChain. На начало 2026 года у него 54 000 звёзд на GitHub и 7 500 форков — фреймворк растёт быстрее всех конкурентов. В отличие от LangGraph, где вы вручную описываете граф переходов, или AutoGen, где оркестрация спрятана внутри, CrewAI предлагает ровно то, что нужно для продакшна: роли агентов, задачи с чёткими целями и готовые процессы (sequential, hierarchical, hybrid).

Подойдёт ли вам CrewAI? Если нужно, чтобы несколько AI-агентов работали в команде, обменивались результатами и принимали решения — это ваш инструмент. В этой статье я разберу установку на VPS, архитектуру, написание первой команды агентов и деплой. Без воды, с кодом.

Что такое CrewAI и зачем он нужен

CrewAI — это фреймворк для создания команд AI-агентов. Каждый агент получает роль, цель и набор инструментов. Агенты работают вместе, обмениваются результатами и выполняют задачи, которые одному агенту не под силу. Звучит просто, но внутри происходит оркестрация с контролем состояния, маршрутизацией и обработкой ошибок.

IBM описывает CrewAI как основной open-source инструмент для multi-agent оркестрации. Главное преимущество перед LangGraph или AutoGen — декларативный подход. Вы описываете, кто должен делать что и в каком порядке, а не пишете граф переходов вручную.

В CrewAI есть три уровня абстракции: агенты (кто выполняет), задачи (что нужно сделать) и процессы (как организована работа). С версии 0.70+ добавили Flows — event-driven пайплайны с сохранением состояния, которые можно ставить на cron и перезапускать после сбоя.

Архитектура CrewAI: агенты, задачи, процессы

Чтобы понимать, как работает CrewAI, нужно разобрать три базовые сущности. На них строится вся система.

Agent (агент) — это AI-сущность с ролью, целью и набором инструментов. Агент получает задачу (task), выполняет её, используя свои инструменты, и возвращает результат. У каждого агента есть роль (role), цель (goal) и описание (backstory), которые влияют на то, как LLM принимает решения. CrewAI поддерживает memory, knowledge (база знаний), structured output и guardrails — всё, что нужно для предсказуемого поведения агента в продакшне.

Task (задача) — это единица работы. У задачи есть описание, ожидаемый результат и назначенный агент. Задачи могут быть последовательными (sequential), когда результат одной задачи передаётся в другую, или независимыми. CrewAI поддерживает callbacks (хуки до/после выполнения), human-in-the-loop (пауза для подтверждения человеком) и guardrails (проверки результата перед переходом к следующей задаче).

Crew (команда) — это группа агентов, которые выполняют набор задач. Процесс (process) определяет порядок: sequential (агенты работают по цепочке), hierarchical (агент-менеджер распределяет задачи) или hybrid (комбинация). Каждый crew работает в своём контексте, и результаты одного crew можно передавать другому через Flows.

Схема выше показывает типичную multi-agent архитектуру на CrewAI. Coordinator Agent получает задачу от пользователя, распределяет её между Researcher, Analyst и Writer, контролирует очередь выполнения и передаёт результат на проверку человеку. На практике таких агентов может быть 5, 10 или 20 — CrewAI масштабируется горизонтально за счёт того, что агенты не блокируют друг друга в очереди.

Установка CrewAI на VPS или локально

Установка CrewAI занимает пару минут. Официальная документация рекомендует использовать uv — быстрый менеджер пакетов на Rust, но работает и обычный pip. Вот минимальный набор для запуска на Linux:

# Установка через pip (локально или на VPS)
pip install crewai

# Или через uv (быстрее)
pip install uv
uv pip install crewai

# Для работы с инструментами — установка расширенной версии
pip install 'crewai[tools]'

# Проверка установки
crewai --version

CrewAI использует OpenAI-совместимый API по умолчанию. Чтобы подключить локальную модель через Ollama, достаточно указать:

export OPENAI_API_BASE=http://localhost:11434/v1
export OPENAI_MODEL_NAME=llama3.2
export OPENAI_API_KEY=ollama

Если вы уже разворачивали Ollama или vLLM, то настройка сведётся к замене переменных окружения. CrewAI не требует GPU для оркестрации — только для инференса LLM. Сам фреймворк легковесный, можно ставить даже на 1 GB VPS, если LLM работает на отдельном сервере.

Создаём первую команду агентов

Допустим, нам нужно написать аналитическую статью про рынок AI-агентов. Один агент собирает данные, второй анализирует, третий пишет текст. Вот как это выглядит на CrewAI:

from crewai import Agent, Task, Crew, Process

# Агент 1: исследователь
researcher = Agent(
    role="Исследователь рынка",
    goal="Собрать актуальные данные о рынке AI-агентов",
    backstory="Ты профессиональный аналитик с 10-летним стажем. "
              "Ты ищешь данные в открытых источниках и умеешь "
              "отличать качественные источники от шума.",
    tools=[search_tool, scrape_tool],
    verbose=True
)

# Агент 2: аналитик
analyst = Agent(
    role="Финансовый аналитик",
    goal="Проанализировать собранные данные и выделить тренды",
    backstory="Ты работаешь в McKinsey и специализируешься "
              "на AI-рынке. Твои отчёты покупают топ-менеджеры "
              "фондов.",
    tools=[data_analysis_tool],
    verbose=True
)

# Агент 3: писатель
writer = Agent(
    role="Технический писатель",
    goal="Написать аналитическую статью на основе данных",
    backstory="Ты ведёшь блог про AI с аудиторией 50K "
              "читателей. Умеешь писать сложные темы простым "
              "языком.",
    verbose=True
)

# Задача 1: сбор данных
task1 = Task(
    description="Собери 10 источников о состоянии рынка "
                "AI-агентов в 2026 году. Включи данные о "
                "финансировании, количестве стартапов и "
                "основных игроках.",
    expected_output="Список из 10 источников с краткими "
                    "выжимками по каждому",
    agent=researcher
)

# Задача 2: анализ
task2 = Task(
    description="Проанализируй собранные данные. Выдели "
                "3 главных тренда, основных игроков и "
                "оцени объём рынка.",
    expected_output="Аналитическая записка на 2 страницы",
    agent=analyst
)

# Задача 3: написание
task3 = Task(
    description="Напиши статью на основе аналитики. "
                "Структура: введение, 3 тренда, "
                "прогноз, заключение.",
    expected_output="Готовая статья в формате Markdown, "
                    "~2000 слов",
    agent=writer
)

# Команда
crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[task1, task2, task3],
    process=Process.sequential,
    verbose=True
)

# Запуск
result = crew.kickoff()
print(result)

Этот код создаёт команду из трёх агентов, которые работают последовательно: исследователь → аналитик → писатель. Каждый агент получает результат предыдущего на вход. CrewAI сам маршрутизирует данные между задачами и агентами — вам не нужно писать связующий код.

Что происходит внутри, когда вы вызываете crew.kickoff(): CrewAI создаёт сессию, в которой агенты обмениваются сообщениями через внутренний event bus. Задачи выполняются в порядке, заданном массивом tasks. Если процесс sequential — результат task1 передаётся в контекст task2 вместе с description. CrewAI вешает на каждую задачу timeout (по умолчанию 5 минут) и автоматически перезапускает задачу при ошибке LLM (до 3 попыток).

Инструменты: как дать агенту доступ к внешним данным

CrewAI поставляется с 85+ готовыми инструментами. Они покрывают типичные задачи: поиск в интернете, парсинг сайтов, работу с файлами, базами данных, кодом, PDF, Excel, API. Инструменты подключаются как обычные Python-объекты:

from crewai_tools import (
    SerperDevTool,     # Поиск в Google
    ScrapeWebsiteTool, # Парсинг страниц
    FileReadTool,      # Чтение файлов
    CodeDocsSearchTool # Поиск по документации
)

search_tool = SerperDevTool()
scrape_tool = ScrapeWebsiteTool()
file_tool = FileReadTool()

Это работает, потому что каждый инструмент реализует интерфейс BaseTool с методом _run(), который принимает строку на вход и возвращает строку результата. CrewAI подставляет инструменты в system prompt агента, и LLM сама решает, когда и какой инструмент вызвать.

Если готового инструмента нет — написать свой просто. CrewAI использует декораторы:

from crewai_tools import tool

@tool("DatabaseQuery")
def query_database(sql: str) -> str:
    """Выполняет SQL-запрос к PostgreSQL и возвращает результат.
    
    Args:
        sql: SQL-запрос для выполнения
    """
    import psycopg2
    conn = psycopg2.connect("dbname=analytics user=...")
    cur = conn.cursor()
    cur.execute(sql)
    rows = cur.fetchall()
    return "\n".join([str(r) for r in rows])

После этого query_database становится инструментом, и агент может вызывать его из своего LLM-промпта. CrewAI сам сериализует аргументы и возвращает результат.

Flows: сложные пайплайны с контролем состояния

CrewAI Flows — это, пожалуй, самая мощная фича для продакшна. Flow — это event-driven пайплайн, в котором шаги общаются через события, а состояние сохраняется в Redis или файлах. В отличие от простого sequential процесса, Flow позволяет:

запускать шаги параллельно (например, ResearcherAgent и DataCollectorAgent одновременно), обрабатывать события и запускать разные ветки в зависимости от результата, сохранять промежуточное состояние и перезапускать flow с места сбоя без потери данных. Ставить на cron и мониторить через встроенный observability-слой.

Вот как выглядит Flow для автоматической генерации и публикации контента:

from crewai.flow import Flow, start, listen, router, or_
from crewai import Agent, Task, Crew

class ContentPublishingFlow(Flow[dict]):
    model = "gpt-4o"

    @start()
    def generate_ideas(self):
        ideas = self.llm.generate("Предложи 5 тем для статьи...")
        self.state["ideas"] = ideas
        return ideas

    @listen(generate_ideas)
    def research(self, ideas):
        crew = Crew(
            agents=[researcher],
            tasks=[research_task(ideas)],
            process=Process.sequential
        )
        return crew.kickoff()

    @listen(research)
    def write_article(self, research_result):
        crew = Crew(
            agents=[writer, editor],
            tasks=[write_task(research_result)],
            process=Process.hierarchical
        )
        return crew.kickoff()

    @router(write_article)
    def quality_check(self, article):
        score = self.llm.generate(
            f"Оцени качество статьи от 1 до 10: {article}"
        )
        if int(score) >= 7:
            return "publish"
        return "revise"

    @listen("publish")
    def publish(self, article):
        # Публикация через API
        pass

    @listen("revise")
    def revise(self, article):
        # Отправить на доработку
        pass

У этого подхода есть важное преимущество: вы можете запустить Flow, он выполняется час, сервер падает, вы перезапускаете — Flow продолжает с последнего сохранённого шага. Данные не теряются, задачи не дублируются.

Каждый шаг Flow оборачивается в транзакцию с idempotency key. Если вы вызвали research и результат уже есть в state — CrewAI не запускает его повторно, а возвращает кешированный результат. Это критично для продакшен-сценариев, где FLOW может работать 10-20 минут и содержать 30+ шагов.

Лучше всего Flows подходят для задач, где один запуск длится дольше минуты: генерация контента, ETL-пайплайны, multi-step исследования, обработка документов. Для простых "спросил-ответил" достаточно обычного sequential процесса.

Деплой CrewAI в продакшн

Для продакшна CrewAI запускают в Docker на VPS. Базовый Dockerfile:

FROM python:3.12-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install 'crewai[tools]'

COPY . .

CMD ["python", "main.py"]

На VPS нужно поднять три сервиса: Ollama (или другой LLM-сервер), сам CrewAI-сервис и Redis для хранения состояния Flows. Redis обязателен, если используете Flows — без него состояние хранится в памяти и теряется при рестарте.

Пример docker-compose.yml:

version: '3.8'
services:
  ollama:
    image: ollama/ollama
    volumes:
      - ollama_data:/root/.ollama
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    restart: unless-stopped

  crewai-service:
    build: .
    depends_on:
      - ollama
      - redis
    environment:
      - OPENAI_API_BASE=http://ollama:11434/v1
      - OPENAI_MODEL_NAME=llama3.2
      - REDIS_URL=redis://redis:6379
    restart: unless-stopped

volumes:
  ollama_data:

Для больших проектов CrewAI Enterprise предлагает облачную платформу с готовым UI, триггерами из Gmail/Slack/Salesforce, RBAC и мониторингом. Но для 80% сценариев достаточно self-hosted решения на VPS — как мы описывали в статье про Open WebUI, инфраструктура почти та же.

Мониторинг в CrewAI Enterprise — это отдельная история: вы видите live-лог каждого агента, время выполнения каждой задачи, количество вызовов LLM по каждому агенту и точки, где flow зависает. В open-source версии мониторинг ограничен verbose=True в консоль, но можно подключить Prometheus через middleware-слой.

Коротко

CrewAI — это не просто очередная библиотека для AI-агентов. Это фреймворк, который закрывает вопросы, с которыми сталкивается любой, кто пробовал собрать multi-agent систему на коленке: кто кому передаёт данные, что делать, если агент упал, как не потерять состояние при перезапуске. CrewAI решает эти задачи на уровне архитектуры, а не хаком.

Сравнение с конкурентами: LangGraph даёт больше контроля над графом, но требует писать много кода для базовых вещей. AutoGen — мощный, но его event-driven модель сложнее в отладке. CrewAI сидит посередине: даёт достаточно контроля для продакшна и достаточно абстракций, чтобы не писать 200 строк на простую задачу. Если вы уже работали с LangGraph, CrewAI покажется более высокоуровневым — и это его фича, а не баг.

Что дальше? Установите CrewAI через pip, создайте свою первую команду из двух агентов (исследователь + писатель) и запустите на локальной LLM через Ollama. Потом добавьте третий агент, инструменты и попробуйте Flow. Когда поймёте, как работают базовые блоки, можно переходить к полноценному развёртыванию на VPS.