Как я за год переквалифицировался в ИИ-инженера: от DevOps до production-ready AI-агентов

Год назад я был типичным DevOps-инженером: настраивал CI/CD, деплоил микросервисы, оптимизировал инфраструктуру. Сегодня я строю AI-агентов для автоматизации бизнес-процессов, и мои клиенты экономят сотни часов в месяц.

Эта статья — не про "как я выучил Python за неделю", а про реальный инженерный путь: от первых экспериментов с ChatGPT API до production-ready систем, которые обрабатывают тысячи запросов в день. Я расскажу про конкретные проекты, инструменты, пайплайны и главное — про ошибки, которые стоили мне времени и денег.

В этой статье:

• Как я начал: от простых скриптов до MCP Protocol

• Три реальных проекта с кодом и метриками

• Инструменты и стек, который работает в production

• Ошибки, которые я бы не повторил

• Пайплайн разработки AI-агента от идеи до деплоя

Содержание

1. С чего всё началось: от DevOps к AI

2. Проект 1: AI-агент для обработки заявок (первый production)

3. Проект 2: MCP Protocol и интеграция с CRM

4. Проект 3: Telegram-бот с автоответами на основе контекста

5. Инструменты и стек: что реально работает

6. Пайплайн разработки: от идеи до production

7. Ошибки и уроки: что я бы сделал по-другому

8. Что дальше: куда двигаться начинающему 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-агента, который:

1. Получает заявку через webhook

2. Анализирует текст (о чём запрос, срочность, бюджет)

3. Обогащает данные (ищет компанию в Google, LinkedIn, Spark)

4. Квалифицирует лид (приоритет A/B/C)

5. Создаёт карточку в 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

1. Стандартизация: Один протокол для всех LLM (Claude, Grok, GPT-4, и т.д.)

2. Безопасность: Контроль доступа на уровне инструментов

3. Переиспользование: Один MCP Server для разных проектов

4. Отладка: Легко логировать все запросы

5. Гибкость: Можно использовать Claude для сложных задач, Grok для анализа трендов, GPT-4 для генерации текста

Результаты

• Время разработки интеграции: с 2 недель до 3 дней

• Переиспользование кода: 70% кода можно использовать в других проектах

• Стабильность: меньше ошибок благодаря стандартизации

---

Проект 3: Telegram-бот с автоответами на основе контекста

Задача

Компания получала 100+ вопросов в день в Telegram. Большинство — типовые:

• "Какие у вас тарифы?"

• "Как подключиться?"

• "Есть ли скидки?"

Поддержка отвечала вручную, тратя 2-3 минуты на каждый вопрос.

Решение

Я создал Telegram-бота на aiogram, который:

1. Получает сообщение от пользователя

2. Ищет похожие вопросы в базе знаний

3. Генерирует ответ через GPT-3.5-turbo

4. Отправляет ответ пользователю

5. Если ответ не подходит — передаёт человеку

Технический стек

- 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 дня)

1. Определить задачу:

   • Что автоматизируем?

   • Какой критерий успеха?

   • Допустимы ли ошибки?

2. Простой скрипт:

   • Минимальный промпт

   • Тест на 5-10 примерах

   • Оценка качества

3. Решение: стоит ли продолжать?

   • Если качество <70% → пересмотреть задачу

   • Если >70% → идём дальше

Этап 2: MVP (3-5 дней)

1. Базовая архитектура:

   • API endpoint

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

   • Простое логирование

2. Тестирование:

   • 50-100 тестовых случаев

   • Метрики: точность, время ответа, стоимость

3. Итерации:

   • Улучшение промптов

   • Добавление контекста

   • Обработка ошибок

Этап 3: Production-ready (1-2 недели)

1. Обработка ошибок:

   • Retry механизм

   • Fallback стратегии

   • Логирование всех ошибок

2. Оптимизация:

   • Кэширование

   • Асинхронная обработка

   • Снижение стоимости (выбор модели)

3. Мониторинг:

   • Метрики качества

   • Стоимость запросов

   • Время ответа

4. Документация:

   • 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: Основы

1. Изучите Python:

   • Базовый синтаксис

   • Работа с API (requests, httpx)

   • Асинхронность (asyncio)

2. Попробуйте OpenAI API:

   • Простые запросы

   • Работа с промптами

   • Понимание токенов и стоимости

3. Сделайте первый проект:

   • Простой бот или скрипт

   • Автоматизация одной задачи

   • Опубликуйте на GitHub

Месяц 2-3: Углубление

1. Изучите LangChain:

   • Цепочки (chains)

   • Агенты (agents)

   • Инструменты (tools)

2. Работа с векторными БД:

   • pgvector

   • Embeddings

   • RAG (Retrieval-Augmented Generation)

3. Второй проект:

   • Что-то более сложное

   • С интеграцией с внешними системами

   • С мониторингом и логированием

Месяц 4-6: Production

1. Изучите MCP Protocol:

   • Создайте свой MCP Server

   • Интеграция с Claude (нативная поддержка)

   • Интеграция с Grok (через API)

   • Сравнение разных LLM для разных задач

2. Оптимизация:

   • Снижение стоимости (выбор модели: Claude для анализа, Grok для трендов, GPT-3.5 для простых задач)

   • Улучшение качества

   • Масштабирование

3. Третий проект:

   • 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-инженера. Главные выводы:

1. AI работает, но нужен правильный подход: Не пытайтесь автоматизировать всё подряд. Начните с простых задач.

2. Инструменты важны: LangChain, MCP Protocol, pgvector — это не просто модные слова, а реально работающие инструменты.

3. Мониторинг критичен: Без метрик вы не поймёте, работает ли система хорошо.

4. Стоимость имеет значение: GPT-4 дорогой. Используйте его только там, где нужно. Claude отлично подходит для анализа, Grok — для работы с актуальными данными, GPT-3.5 — для простых задач.

5. Итерации — это нормально: Первая версия всегда будет плохой. Улучшайте постепенно.

Если у вас есть вопросы или хотите обсудить конкретный проект — пишите в комментарии. Буду рад помочь!

---

Теги: #Искусственный интеллект #Сезон ИИ в разработке #Python #LangChain #MCP Protocol #AI Engineering #Machine Learning

Автор: Алан Форестер
GitHub: @AlanForester
Сайт: forester.pro