КДПВ: Схема эволюции: DevOps → Python разработчик → AI Engineer с примерами проектов на каждом этапе. Альтернатива: скриншот дашборда с метриками AI-агентов в production.
Год назад я был типичным DevOps-инженером: настраивал CI/CD, деплоил микросервисы, оптимизировал инфраструктуру. Сегодня я строю AI-агентов для автоматизации бизнес-процессов, и мои клиенты экономят сотни часов в месяц.
Эта статья — не про "как я выучил Python за неделю", а про реальный инженерный путь: от первых экспериментов с ChatGPT API до production-ready систем, которые обрабатывают тысячи запросов в день. Я расскажу про конкретные проекты, инструменты, пайплайны и главное — про ошибки, которые стоили мне времени и денег.
В этой статье:
Как я начал: от простых скриптов до MCP Protocol
Три реальных проекта с кодом и метриками
Инструменты и стек, который работает в production
Ошибки, которые я бы не повторил
Пайплайн разработки AI-агента от идеи до деплоя
Содержание
С чего всё началось: от DevOps к AI
Я работал DevOps-инженером в компании, которая делала кибер-разведку для банков. Наш продукт собирал данные из открытых источников, анализировал их и генерировал отчёты. Всё шло по накатанной, пока не появился закон.
Проблема: Аналитики тратили 4-6 часов в день на рутинную работу:
Поиск информации о компаниях в разных источниках
Форматирование данных для отчётов
Проверка дублей и очистка данных
Я подумал: "А что, если ChatGPT будет делать это автоматически?"
Первая попытка была наивной: я просто скопировал промпт из ChatGPT в Python-скрипт и запустил через API. Результат? Галлюцинации, неверные данные, потеря контекста. Но я понял главное: AI работает, но нужен правильный подход.
Первые шаги
Я начал с простого: автоматизация генерации email-ответов для поддержки. Не критично, если ошибка, но экономия времени — реальная.
Что я использовал:
OpenAI API (GPT-3.5-turbo)
Python + FastAPI
PostgreSQL для хранения шаблонов
Результат: Поддержка стала отвечать в 3 раза быстрее. Это был первый успех.
Но настоящий прорыв случился, когда я узнал про MCP Protocol (Model Context Protocol). Это стандарт от Anthropic для интеграции LLM с внешними системами. Вместо того чтобы писать костыли с промптами, можно было использовать готовый протокол.
Проект 1: AI-агент для обработки заявок (первый production)
Задача
Компания получала 40-50 заявок в день через форму на сайте. Менеджеры тратили 5-7 минут на каждую:
Поиск информации о компании
Квалификация лида (горячий/холодный)
Создание карточки в CRM
Назначение ответственного
Проблема: Менеджеры не успевали, приоритетные лиды терялись.
Решение
Я построил AI-агента, который:
Получает заявку через webhook
Анализирует текст (о чём запрос, срочность, бюджет)
Обогащает данные (ищет компанию в Google, LinkedIn, Spark)
Квалифицирует лид (приоритет A/B/C)
Создаёт карточку в CRM через API
Технический стек
# Основные компоненты
- FastAPI (веб-сервер)
- OpenAI API (GPT-4 для анализа)
- LangChain (оркестрация)
- PostgreSQL (хранение данных)
- Redis (кэширование)
- Celery (асинхронные задачи)
Архитектура
Webhook → FastAPI → LangChain Agent → OpenAI API
↓
PostgreSQL
↓
CRM API (AmoCRM)
Код (упрощённый пример)
from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI
from langchain.chains import LLMChain
import requests
class LeadProcessor:
def __init__(self):
self.llm = OpenAI(temperature=0)
self.tools = [
Tool(
name="search_company",
func=self.search_company,
description="Ищет информацию о компании в интернете"
),
Tool(
name="create_crm_card",
func=self.create_crm_card,
description="Создаёт карточку в CRM"
)
]
self.agent = initialize_agent(
self.tools,
self.llm,
agent="zero-shot-react-description"
)
def process_lead(self, lead_data):
prompt = f"""
Проанализируй заявку:
Имя: {lead_data['name']}
Компания: {lead_data['company']}
Сообщение: {lead_data['message']}
Задачи:
1. Найди информацию о компании
2. Определи приоритет (A - горячий, B - тёплый, C - холодный)
3. Создай карточку в CRM
"""
result = self.agent.run(prompt)
return result
def search_company(self, query):
# Поиск через Google Search API
# ...
pass
def create_crm_card(self, data):
# Интеграция с AmoCRM API
# ...
pass
Результаты
До автоматизации:
Время обработки: 5-7 минут на заявку
Обрабатывалось: 25-30 заявок из 50
Потеря лидов: ~40%
После автоматизации:
Время обработки: 10-15 секунд
Обрабатывается: 100% заявок
Потеря лидов: <5%
Экономия времени: ~20 часов в неделю
ROI: Окупилось за 2 недели (экономия 1 FTE менеджера).
Что пошло не так (и как исправил)
Проблема 1: Галлюцинации
AI иногда "придумывал" информацию о компаниях, которой не было.
Решение: Добавил валидацию через несколько источников и флаг "requires_review" для сомнительных случаев.
Проблема 2: Дорого
GPT-4 стоит дорого. При 50 заявках в день расходы были ~$50/день.
Решение:
Использую GPT-3.5-turbo для простых задач
GPT-4 только для сложной квалификации
Кэширование похожих запросов
Итог: расходы снизились до $15/день
Проблема 3: Таймауты
OpenAI API иногда отвечал медленно (10-15 секунд).
Решение: Асинхронная обработка через Celery + retry механизм.
Проект 2: MCP Protocol и интеграция с CRM
После первого проекта я понял: нужен стандартный способ интеграции AI с внешними системами. Так я узнал про MCP Protocol.
Что такое MCP Protocol
MCP (Model Context Protocol) — это открытый стандарт от Anthropic для подключения LLM к внешним системам. Вместо того чтобы писать промпты "найди в CRM клиента с именем X", можно использовать готовые инструменты (tools).
Поддержка MCP:
✅ Claude (Anthropic) — нативная поддержка из коробки
✅ Grok (xAI) — частичная поддержка через API
⚠️ GPT-4 — требует дополнительных обёрток
Архитектура
Claude AI ← MCP Server ← CRM API
↓
PostgreSQL
MCP Server — это промежуточный слой, который:
Предоставляет инструменты для LLM (например, "get_customer", "create_task")
Обрабатывает запросы от LLM
Возвращает структурированные данные
Реализация
Я написал MCP Server на Python, который подключается к AmoCRM:
from mcp import Server, Tool
import requests
class CRMMCPServer:
def __init__(self):
self.server = Server("crm-mcp-server")
self.crm_api = AmoCRMAPI()
# Регистрируем инструменты
self.server.add_tool(
Tool(
name="get_customer",
description="Получает информацию о клиенте из CRM",
input_schema={
"type": "object",
"properties": {
"customer_id": {"type": "string"}
}
},
handler=self.get_customer
)
)
self.server.add_tool(
Tool(
name="create_task",
description="Создаёт задачу в CRM",
input_schema={
"type": "object",
"properties": {
"customer_id": {"type": "string"},
"task_text": {"type": "string"}
}
},
handler=self.create_task
)
)
def get_customer(self, customer_id):
return self.crm_api.get_customer(customer_id)
def create_task(self, customer_id, task_text):
return self.crm_api.create_task(customer_id, task_text)
Преимущества MCP
Стандартизация: Один протокол для всех LLM (Claude, Grok, GPT-4, и т.д.)
Безопасность: Контроль доступа на уровне инструментов
Переиспользование: Один MCP Server для разных проектов
Отладка: Легко логировать все запросы
Гибкость: Можно использовать Claude для сложных задач, Grok для анализа трендов, GPT-4 для генерации текста
Результаты
Время разработки интеграции: с 2 недель до 3 дней
Переиспользование кода: 70% кода можно использовать в других проектах
Стабильность: меньше ошибок благодаря стандартизации
Проект 3: Telegram-бот с автоответами на основе контекста
Задача
Компания получала 100+ вопросов в день в Telegram. Большинство — типовые:
"Какие у вас тарифы?"
"Как подключиться?"
"Есть ли скидки?"
Поддержка отвечала вручную, тратя 2-3 минуты на каждый вопрос.
Решение
Я создал Telegram-бота на aiogram, который:
Получает сообщение от пользователя
Ищет похожие вопросы в базе знаний
Генерирует ответ через GPT-3.5-turbo
Отправляет ответ пользователю
Если ответ не подходит — передаёт человеку
Технический стек
- aiogram (Telegram Bot framework)
- OpenAI API (GPT-3.5-turbo)
- PostgreSQL (база знаний)
- pgvector (векторный поиск для похожих вопросов)
- Redis (кэширование частых вопросов)
Архитектура
Telegram → aiogram → FastAPI → OpenAI API
↓
PostgreSQL + pgvector
↓
Redis (кэш)
Код (ключевые части)
from aiogram import Bot, Dispatcher, types
from aiogram.filters import Command
import openai
from pgvector.psycopg2 import register_vector
import psycopg2
class TelegramAIBot:
def __init__(self):
self.bot = Bot(token=TELEGRAM_TOKEN)
self.dp = Dispatcher()
self.openai_client = openai.OpenAI()
self.db = self.init_db()
# Регистрируем обработчики
self.dp.message.register(self.handle_message, types.Message)
async def handle_message(self, message: types.Message):
user_question = message.text
# Ищем похожий вопрос в базе знаний
similar_question = self.find_similar_question(user_question)
if similar_question and similar_question['similarity'] > 0.85:
# Используем готовый ответ
answer = similar_question['answer']
else:
# Генерируем новый ответ
answer = await self.generate_answer(user_question)
# Сохраняем в базу знаний
self.save_to_knowledge_base(user_question, answer)
await message.answer(answer)
def find_similar_question(self, question):
# Векторный поиск через pgvector
query = """
SELECT question, answer,
embedding <=> %s::vector as similarity
FROM knowledge_base
WHERE embedding <=> %s::vector < 0.3
ORDER BY similarity
LIMIT 1
"""
question_embedding = self.get_embedding(question)
cursor = self.db.cursor()
cursor.execute(query, (question_embedding, question_embedding))
result = cursor.fetchone()
if result:
return {
'question': result[0],
'answer': result[1],
'similarity': 1 - result[2] # pgvector возвращает расстояние
}
return None
async def generate_answer(self, question):
# Используем GPT-3.5-turbo для генерации ответа
response = self.openai_client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "Ты помощник поддержки. Отвечай кратко и по делу."},
{"role": "user", "content": question}
],
temperature=0.7,
max_tokens=200
)
return response.choices[0].message.content
def get_embedding(self, text):
# Получаем embedding через OpenAI
response = self.openai_client.embeddings.create(
model="text-embedding-ada-002",
input=text
)
return response.data[0].embedding
Результаты
До автоматизации:
Время ответа: 2-3 минуты
Обрабатывалось: 60-70 вопросов из 100
Нагрузка на поддержку: высокая
После автоматизации:
Время ответа: 2-5 секунд
Обрабатывается: 85-90% вопросов автоматически
Нагрузка на поддержку: снизилась на 80%
Экономия: ~15 часов в неделю
Точность ответов: 92% (проверено на 500 вопросах).
Инструменты и стек: что реально работает
За год я перепробовал кучу инструментов. Вот что осталось в production:
LLM и API
OpenAI API:
✅ GPT-4: для сложных задач (квалификация, анализ)
✅ GPT-3.5-turbo: для простых задач (генерация текста, ответы)
✅ text-embedding-ada-002: для векторного поиска
💰 Стоимость: ~$0.002 за 1K токенов (GPT-3.5)
Anthropic Claude:
✅ Лучше для длинных контекстов (до 200K токенов)
✅ MCP Protocol из коробки
✅ Отличное качество рассуждений и анализа
✅ Хорошо работает с кодом и техническими задачами
💰 Дороже, но качество выше
xAI Grok:
✅ Доступ к актуальной информации через X (Twitter)
✅ Хорошо подходит для анализа трендов и новостей
✅ Более "живой" и менее формальный стиль ответов
✅ Полезен для мониторинга соцсетей и анализа публичных данных
💰 Конкурентная цена
Open-source альтернативы:
Llama 2/3 (Meta): можно запустить локально, но нужна мощная GPU
Mistral: хороший баланс цена/качество
Фреймворки
LangChain:
✅ Оркестрация цепочек
✅ Интеграция с инструментами
⚠️ Может быть избыточным для простых задач
LlamaIndex:
✅ Отлично для RAG (Retrieval-Augmented Generation)
✅ Работа с документами
Haystack:
✅ Хорош для поиска и QA систем
Базы данных
PostgreSQL + pgvector:
✅ Векторный поиск из коробки
✅ Хранение embeddings
✅ Стабильность и производительность
Redis:
✅ Кэширование промптов и ответов
✅ Очереди задач
Мониторинг и логирование
LangSmith (от LangChain):
✅ Трейсинг промптов
✅ Отладка цепочек
💰 Платный, но очень полезен
Custom решение:
Логирование всех запросов в PostgreSQL
Метрики через Prometheus + Grafana
Деплой
Docker + Docker Compose:
✅ Простота развёртывания
✅ Изоляция окружений
Kubernetes:
✅ Для масштабирования
⚠️ Избыточно для небольших проектов
Пайплайн разработки: от идеи до production
За год я выработал чёткий процесс разработки AI-агента:
Этап 1: Прототип (1-2 дня)
Определить задачу:
Что автоматизируем?
Какой критерий успеха?
Допустимы ли ошибки?
Простой скрипт:
Минимальный промпт
Тест на 5-10 примерах
Оценка качества
Решение: стоит ли продолжать?
Если качество <70% → пересмотреть задачу
Если >70% → идём дальше
Этап 2: MVP (3-5 дней)
Базовая архитектура:
API endpoint
Интеграция с LLM
Простое логирование
Тестирование:
50-100 тестовых случаев
Метрики: точность, время ответа, стоимость
Итерации:
Улучшение промптов
Добавление контекста
Обработка ошибок
Этап 3: Production-ready (1-2 недели)
Обработка ошибок:
Retry механизм
Fallback стратегии
Логирование всех ошибок
Оптимизация:
Кэширование
Асинхронная обработка
Снижение стоимости (выбор модели)
Мониторинг:
Метрики качества
Стоимость запросов
Время ответа
Документация:
API документация
Руководство по использованию
Runbook для поддержки
Чек-лист перед production
[ ] Обработка всех типов ошибок
[ ] Retry механизм для API
[ ] Логирование всех запросов
[ ] Мониторинг метрик
[ ] Документация
[ ] Тесты (минимум 80% покрытие)
[ ] Load testing (если ожидается нагрузка)
Ошибки и уроки: что я бы сделал по-другому
Ошибка 1: Слишком сложные промпты
Было: Промпт на 500+ токенов с кучей инструкций.
Проблема: LLM терялся, качество падало.
Решение: Разбить на несколько простых промптов. Цепочка из 3 простых промптов работает лучше, чем 1 сложный.
Ошибка 2: Игнорирование стоимости
Было: Использовал GPT-4 для всех задач.
Проблема: Расходы $100+/день.
Решение:
GPT-3.5-turbo для 80% задач
GPT-4 только для критичных
Кэширование похожих запросов
Итог: расходы снизились в 5 раз
Ошибка 3: Нет обработки ошибок
Было: Если API упал — вся система падала.
Проблема: Пользователи получали ошибки.
Решение:
Retry с экспоненциальной задержкой
Fallback на более простую модель
Очередь задач через Celery
Ошибка 4: Нет мониторинга качества
Было: Не знал, насколько хорошо работает система.
Проблема: Качество деградировало незаметно.
Решение:
Логирование всех ответов
Периодическая проверка человеком (10% случаев)
Метрики: точность, время ответа, стоимость
Ошибка 5: Игнорирование контекста
Было: Каждый запрос обрабатывался изолированно.
Проблема: AI не помнил предыдущие сообщения.
Решение:
Хранение истории в Redis
Передача последних 5-10 сообщений в контекст
Использование RAG для базы знаний
Что дальше: куда двигаться начинающему AI-инженеру
Если вы хотите повторить мой путь, вот план:
Месяц 1: Основы
Изучите Python:
Базовый синтаксис
Работа с API (requests, httpx)
Асинхронность (asyncio)
Попробуйте OpenAI API:
Простые запросы
Работа с промптами
Понимание токенов и стоимости
Сделайте первый проект:
Простой бот или скрипт
Автоматизация одной задачи
Опубликуйте на GitHub
Месяц 2-3: Углубление
Изучите LangChain:
Цепочки (chains)
Агенты (agents)
Инструменты (tools)
Работа с векторными БД:
pgvector
Embeddings
RAG (Retrieval-Augmented Generation)
Второй проект:
Что-то более сложное
С интеграцией с внешними системами
С мониторингом и логированием
Месяц 4-6: Production
Изучите MCP Protocol:
Создайте свой MCP Server
Интеграция с Claude (нативная поддержка)
Интеграция с Grok (через API)
Сравнение разных LLM для разных задач
Оптимизация:
Снижение стоимости (выбор модели: Claude для анализа, Grok для трендов, GPT-3.5 для простых задач)
Улучшение качества
Масштабирование
Третий проект:
Production-ready система
С документацией
С метриками и мониторингом
С использованием нескольких LLM для разных задач
Ресурсы
Курсы:
LangChain для LLM приложений (LangChain docs)
OpenAI API курс (официальная документация)
Сообщества:
LangChain Discord
r/LangChain (Reddit)
AI Engineering (Telegram)
Книги:
"Building LLM Applications" (O'Reilly)
"Prompt Engineering Guide" (GitHub)
Итоги
За год я прошёл путь от DevOps-инженера до AI-инженера. Главные выводы:
AI работает, но нужен правильный подход: Не пытайтесь автоматизировать всё подряд. Начните с простых задач.
Инструменты важны: LangChain, MCP Protocol, pgvector — это не просто модные слова, а реально работающие инструменты.
Мониторинг критичен: Без метрик вы не поймёте, работает ли система хорошо.
Стоимость имеет значение: GPT-4 дорогой. Используйте его только там, где нужно. Claude отлично подходит для анализа, Grok — для работы с актуальными данными, GPT-3.5 — для простых задач.
Итерации — это нормально: Первая версия всегда будет плохой. Улучшайте постепенно.
Если у вас есть вопросы или хотите обсудить конкретный проект — пишите в комментарии. Буду рад помочь!
Теги: #Искусственный интеллект #Сезон ИИ в разработке #Python #LangChain #MCP Protocol #AI Engineering #Machine Learning
Автор: Алан Форестер
GitHub: @AlanForester
Сайт: forester.pro
