MCP Protocol: Как подключить Claude AI к вашей CRM за 2 недели / forpes.ru

Главная
MCP Protocol: Как подключить Claude AI к вашей CRM за 2 недели

MCP Protocol: Как подключить Claude AI к вашей CRM за 2 недели -1

10.11.2025 12:15

alexcollin 0 203 Источник

В этой статье я покажу, как за 2 недели создать MCP-сервер для интеграции Claude AI с AmoCRM. Вы узнаете:

Что такое MCP Protocol и почему это проще, чем кажется
Как создать простой MCP-сервер на Python
Как подключить его к CRM
Реальный кейс: -83% времени на обработку лидов, ROI 340%

Проблема: Почему интеграция AI с бизнес-системами такая сложная?

Представьте: вы хотите, чтобы ChatGPT или Claude помогал вашим менеджерам работать с CRM. Звучит просто, правда?

На практике оказывается сложнее. Вам нужно:

Написать API wrapper для вашей CRM
Создать промпты для LLM
Синхронизировать данные между системами
Обрабатывать ошибки
Масштабировать всё это
Поддерживать при обновлениях

На это уходит 2-3 месяца разработки.

И самое неприятное: если через год вы захотите подключить другую LLM (скажем, переехать с GPT на Claude), придется переписывать половину кода заново.

Решение: MCP Protocol — стандарт интеграции AI

В конце 2024 года Anthropic (создатели Claude) представили Model Context Protocol. Это открытый стандарт для интеграции LLM с внешними системами.

Простыми словами: MCP — это как HTTP для AI.

Вспомните, как работает веб. Раньше каждый браузер по-своему подключался к серверам. Появление HTTP стандартизировало это — теперь один сервер работает со всеми браузерами.

MCP делает то же самое для AI. Вы один раз пишете MCP-сервер для своей CRM, и он работает с:

Claude AI
ChatGPT
Любой другой LLM, поддерживающей MCP

Как это работает на практике

Представьте диалог менеджера с AI:

Менеджер: "Найди контакт Иван Петров и покажи все его сделки"

Claude (через MCP):

Понимает запрос
Вызывает функцию search_contact("Иван Петров") через MCP-сервер
Получает ID контакта
Вызывает функцию get_deals(contact_id) через MCP-сервер
Форматирует результат красиво для менеджера

Менеджер видит:

Иван Петров
Email: ivan@example.com
Телефон: +7 999 123-45-67

Сделки:
1. "Покупка ПО" — 150,000₽ — В работе
2. "Консультация" — 50,000₽ — Закрыта
3. "Внедрение" — 300,000₽ — Обсуждение

Последний контакт: 2 дня назад

Время: 10 секунд вместо 5 минут ручного поиска.

Создаем свой первый MCP-сервер

Давайте создадим простой MCP-сервер для AmoCRM. Понадобится только Python и базовые знания API.

Шаг 1: Установка зависимостей

pip install mcp anthropic fastapi aiohttp python-dotenv

Что мы установили:

mcp — SDK для создания MCP-серверов
anthropic — для работы с Claude AI
fastapi — веб-фреймворк (MCP-сервер это HTTP сервер)
aiohttp — для запросов к API AmoCRM

Шаг 2: Получаем токен AmoCRM

Заходим в настройки AmoCRM → Интеграции → API → Создаем токен.

Сохраняем в .env:

AMOCRM_TOKEN=your_token_here
AMOCRM_DOMAIN=yourcompany.amocrm.ru

Шаг 3: Создаем MCP-сервер

Создайте файл amocrm_mcp_server.py:

from mcp import MCPServer, Tool
from fastapi import FastAPI
import aiohttp
import os
from dotenv import load_dotenv

load_dotenv()

# Настройки AmoCRM
AMOCRM_TOKEN = os.getenv("AMOCRM_TOKEN")
AMOCRM_DOMAIN = os.getenv("AMOCRM_DOMAIN")
AMOCRM_URL = f"https://{AMOCRM_DOMAIN}"

# Создаем FastAPI приложение
app = FastAPI()

# Создаем MCP-сервер
mcp_server = MCPServer(name="amocrm-integration")

# Инструмент 1: Поиск контакта
@mcp_server.tool()
async def search_contact(query: str) -> dict:
    """
    Ищет контакт в AmoCRM по имени, email или телефону.
    
    AI-агент использует эту функцию, когда менеджер просит
    "найди контакт Иван Петров".
    """
    async with aiohttp.ClientSession() as session:
        headers = {"Authorization": f"Bearer {AMOCRM_TOKEN}"}
        url = f"{AMOCRM_URL}/api/v4/contacts"
        params = {"query": query}
        
        async with session.get(url, headers=headers, params=params) as resp:
            if resp.status != 200:
                return {"error": "Не удалось найти контакт"}
            
            data = await resp.json()
            contacts = data.get("_embedded", {}).get("contacts", [])
            
            # Возвращаем только нужные поля
            return {
                "contacts": [
                    {
                        "id": c["id"],
                        "name": c["name"],
                        "email": get_field(c, "EMAIL"),
                        "phone": get_field(c, "PHONE")
                    }
                    for c in contacts
                ]
            }

# Вспомогательная функция для извлечения полей
def get_field(contact, field_code):
    """Достает email или телефон из custom_fields_values"""
    custom_fields = contact.get("custom_fields_values", [])
    for field in custom_fields:
        if field.get("field_code") == field_code:
            values = field.get("values", [])
            return values[0].get("value") if values else None
    return None

# Инструмент 2: Получение сделок контакта
@mcp_server.tool()
async def get_contact_deals(contact_id: int) -> dict:
    """
    Получает все сделки контакта из AmoCRM.
    
    Показывает историю взаимодействия с клиентом.
    """
    async with aiohttp.ClientSession() as session:
        headers = {"Authorization": f"Bearer {AMOCRM_TOKEN}"}
        url = f"{AMOCRM_URL}/api/v4/leads"
        params = {"filter[contacts][id]": contact_id}
        
        async with session.get(url, headers=headers, params=params) as resp:
            if resp.status != 200:
                return {"error": "Не удалось получить сделки"}
            
            data = await resp.json()
            deals = data.get("_embedded", {}).get("leads", [])
            
            return {
                "deals": [
                    {
                        "id": d["id"],
                        "name": d["name"],
                        "price": d["price"],
                        "status_id": d["status_id"],
                        "created_at": d["created_at"]
                    }
                    for d in deals
                ]
            }

# Запускаем сервер
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Что мы создали?

Мы написали HTTP сервер с двумя функциями:

search_contact — ищет контакт в CRM
get_contact_deals — показывает сделки контакта

Это и есть MCP-сервер! Всего 80 строк кода.

Шаг 4: Подключаем к Claude AI

Теперь создадим клиента, который соединит Claude с нашим MCP-сервером:

# client.py

from anthropic import Anthropic
from mcp import MCPClient

# Подключаемся к нашему MCP-серверу
mcp_client = MCPClient("http://localhost:8000")

# Создаем клиента Claude
client = Anthropic(api_key="ваш_ключ_claude")

# Теперь можно задавать вопросы
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    mcp_servers=[mcp_client],  # Даем Claude доступ к нашему серверу
    messages=[{
        "role": "user",
        "content": "Найди контакт Иван Петров и покажи его сделки"
    }]
)

print(response.content)

Запускаем:

# Терминал 1: Запускаем MCP-сервер
python amocrm_mcp_server.py

# Терминал 2: Запускаем клиента
python client.py

Результат:

Нашел контакт:
Иван Петров
Email: ivan@example.com
Телефон: +7 999 123-45-67

У него 3 сделки:
1. "Покупка ПО" — 150,000₽ — В работе (ID: 12345)
2. "Консультация" — 50,000₽ — Закрыта (ID: 12344)
3. "Внедрение" — 300,000₽ — Обсуждение (ID: 12346)

Магия! Claude сам вызвал нужные функции, получил данные и красиво их отформатировал.

Реальный кейс: E-commerce компания

Давайте посмотрим, как это работает в production.

До внедрения:

Процесс обработки лида:

Заявка падает на сайт → 2 минуты (вручную смотрим)
Ищем компанию в Google → 5 минут
Смотрим LinkedIn, сайт → 8 минут
Создаем контакт в CRM → 3 минуты
Записываем всю найденную информацию → 5 минут
Пишем персонализированное письмо → 10 минут

Итого: 30 минут на один лид.

При 50 лидах в день:

25 часов работы
2 менеджера по 8 часов = 16 часов
Физически не успевают

Результат:

Лиды теряются
Ответ через 1-2 дня (клиент уже у конкурентов)
Конверсия: 12%

После внедрения MCP:

Новый процесс:

Заявка → AI-агент автоматически:
- Ищет компанию (Google, LinkedIn)
- Определяет размер, отрасль
- Квалифицирует лид (A/B/C)
- Создает контакт в CRM
- Генерирует персонализированное письмо
- Все это за 30 секунд
Менеджер получает:
- Готовый brief о клиенте
- Готовое письмо
- Приоритет (A/B/C)
- Время менеджера: 5 минут (просто проверить и отправить)

Результаты за 3 месяца:

Время обработки: 30 мин → 5 мин (-83%)
Конверсия: 12% → 18% (+50%, быстрый ответ работает!)
Экономия: 15 часов/неделю команды
ROI: 340%

Стоимость проекта: 160,000₽
Окупилось за: 2 месяца

Как это устроено внутри

Давайте разберем, что происходит, когда менеджер спрашивает Claude: "Покажи информацию о компании ООО Ромашка"

1. Claude получает запрос

Claude — это просто языковая модель. Она не знает про вашу CRM, клиентов или сделки. Она видит только текст вашего вопроса.

Но благодаря MCP, Claude знает, что есть доступные инструменты:

search_contact(query) — поиск контакта
get_contact_deals(contact_id) — получить сдел��и
create_task(contact_id, text) — создать задачу

2. Claude планирует действия

Claude думает: "Мне нужно найти компанию. Есть функция search_contact. Использую её."

И вызывает:

search_contact("ООО Ромашка")

3. MCP-сервер обрабатывает запрос

Наш Python сервер получает вызов функции и делает HTTP запрос к AmoCRM API:

GET https://yourcompany.amocrm.ru/api/v4/contacts?query=ООО Ромашка
Authorization: Bearer your_token

AmoCRM возвращает данные. МЦП-сервер форматирует их и отдает обратно Claude.

4. Claude получает данные

Claude видит:

{
  "contacts": [{
    "id": 12345,
    "name": "ООО Ромашка",
    "email": "info@romashka.ru",
    "phone": "+7 495 123-45-67"
  }]
}

5. Claude думает дальше

"Нашел контакт. ID = 12345. Теперь нужны сделки. Есть функция get_contact_deals."

Вызывает:

get_contact_deals(12345)

6. Процесс повторяется

MCP-сервер запрашивает сделки из AmoCRM, возвращает Claude.

7. Claude форматирует ответ

Получив все данные, Claude пишет красивый ответ менеджеру:

ООО Ромашка
━━━━━━━━━━━━━━━
Контакт: Иван Иванов
Email: info@romashka.ru
Телефон: +7 495 123-45-67

Сделки (3):
1. "Покупка ПО" — 150,000₽ — В работе
   Создана: 15 октября
   
2. "Консультация" — 50,000₽ — Закрыта
   Оплачена: 1 ноября
   
3. "Внедрение" — 300,000₽ — Обсуждение
   Создана: 5 ноября

Рекомендация: Связаться по сделке "Внедрение" — 
прошло 3 дня с момента создания.

Весь этот процесс занял 5-10 секунд.

Почему это быстрее обычного подхода

Обычный подход (без MCP):

# Нужно писать специфичный код для каждой LLM

def process_with_gpt(query):
    # Код для GPT
    prompt = f"Найди контакт: {query}"
    response = openai.ChatCompletion.create(...)
    
    # Парсим ответ (GPT вернет текст)
    contact_name = extract_from_text(response)
    
    # Делаем запрос к CRM
    contact = crm_api.search(contact_name)
    
    # Формируем ответ для GPT
    context = format_contact(contact)
    
    # Запрашиваем GPT снова с контекстом
    final = openai.ChatCompletion.create(context=context)
    
    return final

# Если захотим Claude — переписываем заново!

Проблемы:

Много кода
Сложная логика парсинга
Привязка к одной LLM
Сложно масштабировать

С MCP:

@mcp_server.tool()
async def search_contact(query: str) -> dict:
    """Ищет контакт. Всё."""
    return await crm_api.search(query)

Преимущества:

Минимум кода
Работает с любой LLM
Claude сам решает, когда вызывать
Легко добавлять новые функции

Что можно сделать дальше

Базовый MCP-сервер готов. Теперь можно расширять возможности:

Обогащение лидов:

@mcp_server.tool()
async def enrich_lead(company_name: str) -> dict:
    """
    Автоматически ищет информацию о компании:
    - Сайт компании
    - Количество сотрудников (LinkedIn)
    - Недавние новости
    - ЛПР (кто принимает решения)
    """
    # Поиск в интернете
    google_data = await search_google(company_name)
    linkedin_data = await search_linkedin(company_name)
    
    return {
        "company": company_name,
        "website": google_data.get("website"),
        "employees": linkedin_data.get("size"),
        "decision_makers": linkedin_data.get("people")
    }

Теперь AI может автоматически обогащать каждый лид полезной информацией.

Генерация писем:

@mcp_server.resource("email-templates")
async def get_email_templates() -> str:
    """
    Возвращает шаблоны писем для разных ситуаций.
    
    AI использует их как reference при генерации
    персонализированных писем.
    """
    return """
    # Шаблоны писем
    
    ## Первый контакт с лидом:
    Тема: [Имя], решение для [проблема] в [Компания]
    
    Привет, [Имя]!
    
    Заметил, что в [Компания] используете [система].
    Мы помогли [похожей компании] [результат].
    
    Интересно обсудить?
    
    ## Follow-up через 3 дня:
    ...
    """

Claude будет использовать эти шаблоны как основу, но персонализировать под каждого клиента.

Аналитика и отчеты:

@mcp_server.tool()
async def generate_weekly_report() -> dict:
    """
    Генерирует еженедельный отчет по продажам:
    - Сколько лидов
    - Конверсия
    - Средний чек
    - Топ менеджеры
    """
    # Получаем данные за неделю
    leads = await get_leads_this_week()
    deals = await get_closed_deals()
    
    return {
        "leads": len(leads),
        "conversion": len(deals) / len(leads) * 100,
        "avg_deal": sum(d.price for d in deals) / len(deals)
    }

Теперь менеджер может просто написать: "Покажи отчет за неделю", и Claude сгенерирует его за секунды.

Метрики: До и После

Было (без AI):

Поиск клиента:

Открыть CRM → 10 секунд
Ввести имя → 5 секунд
Найти нужного (если несколько) → 30 секунд
Открыть карточку → 5 секунд
Посмотреть сделки → 20 секунд
Прочитать историю → 2 минуты Итого: 3-5 минут

Подготовка письма:

Вспомнить контекст → 2 минуты
Найти похожее письмо → 3 минуты
Переделать под клиента → 5 минут
Проверить → 2 минуты Итого: 10-12 минут

Создание отчета:

Выгрузить данные из CRM → 5 минут
Открыть Excel → 1 минута
Посчитать метрики → 10 минут
Создать графики → 15 минут
Форматировать → 10 минут Итого: 40-45 минут

Стало (с MCP + Claude):