Архитектура AI-автоматизации: триггеры → агенты → действия

// n8n Workflow JSON — автоматическая обработка заказа
// Триггер: Webhook (новый заказ из интернет-магазина)
{
  "name": "AI Order Processing Pipeline",
  "nodes": [
    {
      "name": "Webhook Trigger",
      "type": "n8n-nodes-base.webhook",
      "parameters": {
        "httpMethod": "POST",
        "path": "/new-order",
        "responseMode": "responseNode"
      }
    },
    {
      "name": "AI Order Classifier",
      "type": "@n8n/n8n-nodes-langchain.chainLlm",
      "parameters": {
        "prompt": "Классифицируй заказ: \nТовары: {{items}}\nСумма: {{total}}\n\nОтветь JSON: {priority, category, needs_review}",
        "model": "gpt-4o"
      }
    },
    {
      "name": "If High Priority",
      "type": "n8n-nodes-base.if",
      "parameters": {
        "conditions": {
          "string": [
            { "value1": "={{ json.priority }}", "operation": "equals", "value2": "high" }
          ]
        }
      }
    },
    {
      "name": "Slack Alert",
      "type": "n8n-nodes-base.slack",
      "parameters": { "channel": "#orders-urgent", "text": "⚡ Срочный заказ #{{orderId}}" }
    },
    {
      "name": "Generate Invoice PDF",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://invoice-api/generate",
        "method": "POST",
        "body": "{ \"order\": {{ json }} }"
      }
    },
    {
      "name": "Send Confirmation Email",
      "type": "n8n-nodes-base.emailSend",
      "parameters": {
        "to": "={{ json.customer_email }}",
        "subject": "Заказ #{{orderId}} принят в обработку",
        "text": "Ваш заказ подтверждён. Ожидаемая дата доставки: {{deliveryDate}}"
      }
    }
  ],
  "connections": {
    "Webhook Trigger": { "main": [[{ "node": "AI Order Classifier" }]] },
    "AI Order Classifier": { "main": [[{ "node": "If High Priority" }]] },
    "If High Priority": {
      "main": [[{ "node": "Slack Alert" }]],
      "false": [[{ "node": "Generate Invoice PDF" }]]
    },
    "Slack Alert": { "main": [[{ "node": "Generate Invoice PDF" }]] },
    "Generate Invoice PDF": { "main": [[{ "node": "Send Confirmation Email" }]] }
  }
}
    

# crewai_competitive_analysis.py
# Автоматический анализ конкурентов: исследование → отчёт → email
from crewai import Agent, Task, Crew, Process
from crewai.tools import tool
import httpx, smtplib
from email.mime.text import MIMEText

# --- Кастомные инструменты ---
@tool("web_scraper")
def web_scraper(url: str) -> str:
    """Собирает контент со страницы конкурента."""
    with httpx.Client(timeout=30) as client:
        resp = client.get(url, headers={"User-Agent": "CrewAI/1.0"})
    return resp.text[:8000]  # первые 8K символов

@tool("send_report_email")
def send_report_email(to: str, subject: str, body: str) -> str:
    """Отправляет готовый отчёт по email."""
    msg = MIMEText(body, "plain", "utf-8")
    msg["Subject"] = subject
    msg["To"] = to
    with smtplib.SMTP("smtp.gmail.com", 587) as s:
        s.starttls(); s.login("bot@company.com", "app-password")
        s.send_message(msg)
    return f"Отчёт отправлен на {to}"

# --- Определение агентов ---
researcher = Agent(
    role="Research Analyst",
    goal="Собрать и проанализировать публичную информацию о конкурентах",
    backstory="Эксперт по конкурентной разведке с 10-летним опытом.",
    tools=[web_scraper],
    verbose=True,
    allow_delegation=False
)

analyst = Agent(
    role="Senior Business Analyst",
    goal="Выявить ключевые угрозы и возможности на основе данных",
    backstory="Стратег, помогающий компаниям обходить конкурентов.",
    verbose=True,
    allow_delegation=False
)

reporter = Agent(
    role="Report Writer",
    goal="Составить структурированный отчёт и отправить руководству",
    backstory="Профессиональный технический писатель, лаконичный и точный.",
    tools=[send_report_email],
    verbose=True,
    allow_delegation=False
)

# --- Задачи с ожидаемым результатом ---
task_research = Task(
    description="Собери данные о сайтах конкурентов из списка: {competitors}. Верни резюме по каждому.",
    expected_output="Структурированное резюме по каждому конкуренту: продукты, цены, УТП.",
    agent=researcher
)

task_analyze = Task(
    description="Проанализируй данные и выдели 3 главные угрозы и 3 возможности.",
    expected_output="SWOT-подобный анализ с конкретными рекомендациями.",
    agent=analyst
)

task_report = Task(
    description="Составь отчёт в формате Markdown и отправь на ceo@company.com.",
    expected_output="Отчёт на русском языке: Executive Summary → Анализ → Рекомендации.",
    agent=reporter
)

# --- Запуск команды (последовательный процесс) ---
crew = Crew(
    agents=[researcher, analyst, reporter],
    tasks=[task_research, task_analyze, task_report],
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff(inputs={"competitors": "example.com, rival.io, competitor.org"})
print(f"✅ Crew завершён:\n{result}")
    

# langgraph_refund_workflow.py
# Автоматическая обработка возврата с обязательным одобрением менеджером
from typing import TypedDict, Literal
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_openai import ChatOpenAI

# --- Состояние графа ---
class RefundState(TypedDict):
    order_id: str          # ID заказа
    amount: float          # Сумма возврата
    reason: str           # Причина
    fraud_score: float     # Оценка риска (0-1)
    ai_decision: str       # Решение AI: approve/deny/escalate
    human_approved: bool    # Подтверждение менеджером
    result: str            # Финальный результат

llm = ChatOpenAI(model="gpt-4o", temperature=0)

# --- Узлы графа ---
def validate_order(state: RefundState) -> RefundState:
    """Проверяет существование заказа в БД."""
    # В реальности — запрос к PostgreSQL / Shopify API
    if not state["order_id"]:
        state["result"] = "ORDER_NOT_FOUND"
    return state

def analyze_fraud(state: RefundState) -> RefundState:
    """AI-анализ на мошенничество."""
    prompt = f"Оцени риск возврата (0-1). Сумма: {state['amount']}₽, причина: {state['reason']}. Ответь ТОЛЬКО числом."
    score = float(llm.invoke(prompt).content.strip())
    state["fraud_score"] = min(max(score, 0), 1.0)
    return state

def make_ai_decision(state: RefundState) -> RefundState:
    """Принимает предварительное решение: одобрить / отклонить / эскалировать."""
    if state["fraud_score"] > 0.7 or state["amount"] > 50_000:
        state["ai_decision"] = "escalate"
    elif state["fraud_score"] < 0.3:
        state["ai_decision"] = "approve"
    else:
        state["ai_decision"] = "deny"
    return state

def process_refund(state: RefundState) -> RefundState:
    """Выполняет возврат через платёжный шлюз."""
    # Здесь вызов Stripe/YooKassa refund API
    state["result"] = f"REFUND_PROCESSED: {state['amount']}₽ возвращены"
    return state

def notify_rejection(state: RefundState) -> RefundState:
    """Уведомляет клиента об отказе."""
    state["result"] = f"REFUND_DENIED: высокий риск (score={state['fraud_score']})"
    return state

# --- Условная маршрутизация ---
def route_after_validation(state: RefundState) -> Literal["analyze_fraud", "__end__"]:
    if state.get("result") == "ORDER_NOT_FOUND":
        return "__end__"   # завершаем, заказа нет
    return "analyze_fraud"

def route_after_ai_decision(state: RefundState) -> Literal["process_refund", "notify_rejection"]:
    if state["ai_decision"] == "approve" and state["human_approved"]:
        return "process_refund"
    return "notify_rejection"

# --- Построение графа ---
builder = StateGraph(RefundState)

builder.add_node("validate_order", validate_order)
builder.add_node("analyze_fraud", analyze_fraud)
builder.add_node("make_ai_decision", make_ai_decision)
builder.add_node("process_refund", process_refund)
builder.add_node("notify_rejection", notify_rejection)

builder.set_entry_point("validate_order")
builder.add_conditional_edges("validate_order", route_after_validation)
builder.add_edge("analyze_fraud", "make_ai_decision")
builder.add_conditional_edges("make_ai_decision", route_after_ai_decision)
builder.add_edge("process_refund", END)
builder.add_edge("notify_rejection", END)

# Компиляция с чекпоинтами (human-in-the-loop)
memory = MemorySaver()
graph = builder.compile(checkpointer=memory)

# --- Запуск ---
config = {"configurable": {"thread_id": "refund-8891"}}
initial = {"order_id": "ORD-2026-0551", "amount": 12_500, "reason": "Брак", "human_approved": False}

# Запускаем до точки прерывания (ждём подтверждения человека)
for event in graph.stream(initial, config):
    print(f"▸ {event}")

# Менеджер проверяет решение AI и подтверждает:
# graph.update_state(config, {"human_approved": True})
# for event in graph.stream(None, config):  # продолжает с места остановки
#     print(f"▶ {event}")
    

// n8n: Webhook → AI Classify → PostgreSQL → Trigger CrewAI
{
  "nodes": [
    { "name": "Lead Webhook", "type": "n8n-nodes-base.webhook",
      "parameters": { "path": "/lead-capture", "httpMethod": "POST" }
    },
    { "name": "AI Lead Scoring", "type": "@n8n/n8n-nodes-langchain.chainLlm",
      "parameters": {
        "prompt": "Оцени лид: компания={{company}}, должность={{role}}, источник={{source}}. \nВерни JSON: {score:1-10, industry, persona, recommended_sequence}"
      }
    },
    { "name": "Save to PostgreSQL", "type": "n8n-nodes-base.postgres",
      "parameters": {
        "query": "INSERT INTO leads (email, score, persona, sequence) VALUES ({{email}}, {{score}}, {{persona}}, {{sequence}}) ON CONFLICT (email) DO UPDATE SET score=EXCLUDED.score"
      }
    },
    { "name": "Kickoff CrewAI", "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "http://crewai-api:8000/generate-sequence",
        "method": "POST",
        "body": "{ \"email\": \"{{email}}\", \"persona\": \"{{persona}}\", \"industry\": \"{{industry}}\" }"
      }
    }
  ]
}
    

# crewai_email_sequence.py — запускается через FastAPI эндпоинт
from crewai import Agent, Task, Crew, Process

copywriter = Agent(
    role="Email Copywriter",
    goal="Создать цепочку из 3 персонализированных писем для лида",
    backstory="Копирайтер с опытом в B2B SaaS. Пишет коротко, без воды, с чёткими CTA.",
    verbose=True
)

reviewer = Agent(
    role="Quality Reviewer",
    goal="Проверить письма на ошибки, спам-слова и релевантность индустрии {industry}",
    backstory="Перфекционист-редактор. Знает все триггеры спам-фильтров.",
    verbose=True
)

task_write = Task(
    description="Напиши welcome-серию из 3 писем для {persona} в индустрии {industry}. Письмо 1: знакомство и ценность. Письмо 2: кейс. Письмо 3: специальное предложение. Ответь JSON-массивом: [{subject, body, delay_hours}].",
    expected_output="JSON с тремя письмами и задержками отправки (24ч, 48ч, 72ч).",
    agent=copywriter
)

task_review = Task(
    description="Проверь письма: нет ли спам-слов, корректны ли ссылки, подходит ли тон для {industry}.",
    expected_output="Исправленный JSON или пометка 'approved'.",
    agent=reviewer
)

crew = Crew(agents=[copywriter, reviewer], tasks=[task_write, task_review], process=Process.sequential)
result = crew.kickoff(inputs={"persona": persona, "industry": industry})
print(f"✅ Email sequence ready:\n{result}")
    

# ROI калькулятор AI-автоматизации
# Исходные данные для команды поддержки из 5 человек

manual_cost_per_month  = 5 * 120_000          # 5 сотрудников × 120K ₽
tickets_per_month        = 2_000             # 2000 обращений в месяц
automation_rate          = 0.75              # 75% автоматизируется
automated_tickets        = 1_500             # 2000 * 0.75

# Затраты на AI (LLM + инфраструктура)
llm_cost_per_ticket      = 0.05              # $0.05 на тикет (GPT-4o-mini)
infra_cost_per_month     = 8_000             # Сервер + n8n/DB — 8000 ₽
ai_total_cost            = automated_tickets * llm_cost_per_ticket * 90 + infra_cost_per_month
                            # 1500 * 0.05 * 90₽ + 8000 = 6750 + 8000
ai_total_cost            = 14_750            # ₽/месяц

# После автоматизации: сокращение до 2 сотрудников
new_staff_cost           = 2 * 120_000          # 240 000 ₽
total_new_cost           = new_staff_cost + ai_total_cost
                            # 240 000 + 14 750 = 254 750 ₽

monthly_savings          = manual_cost_per_month - total_new_cost
                            # 600 000 - 254 750 = 345 250 ₽/мес

annual_savings           = monthly_savings * 12  # 4 143 000 ₽/год

print(f"💰 Экономия: {monthly_savings:,.0f} ₽/мес | {annual_savings:,.0f} ₽/год")
print(f"📊 Автоматизировано: {automated_tickets} тикетов ({automation_rate:.0%})")
print(f"⚡ Среднее время ответа: с 4 часов до < 30 секунд")
# Вывод:
# 💰 Экономия: 345 250 ₽/мес | 4 143 000 ₽/год
# 📊 Автоматизировано: 1500 тикетов (75%)
# ⚡ Среднее время ответа: с 4 часов до < 30 секунд