[00:00] (0.04s)
Привет, я Олег. В реальной жизни я кэнд
[00:02] (2.28s)
разработчик, но по вечерам я скорее
[00:04] (4.12s)
вайп-кодер. Пишу свои микропроекты в
[00:06] (6.16s)
соло с помощью AI инструментов.
[00:08] (8.44s)
Последнее время в интернете всё чаще
[00:10] (10.00s)
говорят об MCP- серверах. Я попробовал
[00:12] (12.04s)
заюзать их в разработке своих
[00:13] (13.52s)
микропроектов, и это реально имба.
[00:15] (15.40s)
Последние 2 месяца я не провожу без них
[00:17] (17.24s)
ни дня. Они жёстко бустанули не только
[00:19] (19.16s)
процесс написания кода, но ещё и
[00:21] (21.32s)
исследования тем, проработку разных
[00:23] (23.60s)
идей. В общем, MCP-серверы могут
[00:25] (25.52s)
ускорить и прокачать практически любую
[00:27] (27.52s)
работу, выполняемую за компом. В этом
[00:29] (29.56s)
видео расскажу всё, что я знаю о
[00:30] (30.96s)
протоколе MCP. Покажу, как подключить,
[00:33] (33.04s)
настроить и использовать любые
[00:34] (34.44s)
MCP-серверы. Поделюсь ошибками, которые
[00:36] (36.52s)
я встретил при работы MCP. Подкину пару
[00:38] (38.76s)
лайфхаков, как избегать подобных
[00:40] (40.36s)
проблем, не потратить кучу денег и
[00:42] (42.60s)
почувствовать всю мощь MCP-сервера.
[00:44] (44.76s)
Погнали. MCP расшифровывается как model
[00:47] (47.68s)
context протокол. Это открытый стандарт,
[00:49] (49.96s)
который ввёл OPC в конце двадцать
[00:52] (52.36s)
четвёртого года, чтобы подружить любые
[00:54] (54.56s)
lm нейронки с любым внешним контекстом,
[00:57] (57.28s)
например, базами данных. файлами, API,
[01:00] (60.56s)
браузером и любым другим инструментом.
[01:03] (63.28s)
Обычно MCP сравнивают с USB, потому что
[01:05] (65.40s)
он является универсальной интеграции
[01:07] (67.16s)
между любыми нейронками и любыми
[01:09] (69.24s)
инструментами. При этом код не нужно
[01:11] (71.12s)
переписывать. Прикол такого открытого
[01:13] (73.00s)
протокола в том, что хоть его и
[01:14] (74.96s)
придумали в Trроopic, он совместим не
[01:17] (77.00s)
только с нейросетью Clot. Его сейчас
[01:18] (78.76s)
поддерживают новые нейронки от Open AI,
[01:21] (81.08s)
от Google. Скорее всего, он будет и
[01:22] (82.84s)
поддерживаться в остальных. На данным
[01:24] (84.32s)
моментом CP - это стандартная индустрии
[01:26] (86.72s)
для подключения инструментов к
[01:28] (88.16s)
нейронкам. Зачем нужны MCP-серверы? Как
[01:30] (90.40s)
говорил ранее, MCP-серверы позволяют
[01:32] (92.16s)
нейронке получать любые данные,
[01:34] (94.00s)
совершать любые действия, не меняя код
[01:36] (96.40s)
приложения. То есть ты можешь попросить
[01:38] (98.24s)
нейронку найти что-то в интернете,
[01:40] (100.20s)
сохранить файл, залезть в базу, и она
[01:43] (103.16s)
это сделает, если у тебя есть нужный
[01:45] (105.32s)
MCP-сервер. Это значительно усиливает
[01:47] (107.36s)
взаимодействие с ЛЛэмкой, ускоряет
[01:49] (109.16s)
работу за компом. Тебе не нужно
[01:50] (110.60s)
копировать из чата в чат данные и
[01:52] (112.32s)
вызывать руками какие-то внешние
[01:53] (113.92s)
программы. Как использовать MCP-серверы?
[01:56] (116.32s)
Для этого есть MCP-клиенты. MCP-клиент -
[01:59] (119.00s)
это приложение, которое объединяет себе
[02:00] (120.64s)
две части. Первое - это вызов запросов к
[02:03] (123.12s)
нейронкам. Второе - это запуск и вызов
[02:05] (125.40s)
запросов к MCP-серверу. Такая комбинация
[02:07] (127.56s)
позволяет достичь такого процесса, где
[02:09] (129.84s)
нейронка сама решает, когда вызвать
[02:11] (131.80s)
инструмент и какие параметры в него
[02:13] (133.76s)
передать. То есть ты просто даёшь
[02:15] (135.32s)
задание, а нейросеть сама решает, когда
[02:17] (137.88s)
и что вызвать. А вот самые популярные
[02:20] (140.00s)
MCP-клиенты - это курсор или его аналог
[02:22] (142.92s)
Winserf. Это, по сути, обычная среда
[02:25] (145.36s)
разработки, но с интегрированным
[02:27] (147.12s)
LLM-агентом. В курсоре недавно добавили
[02:29] (149.20s)
поддержку MCP, и это значительно
[02:30] (150.76s)
расширил возможности программы. А
[02:32] (152.48s)
следующий клиент - это Clud Stop. Это,
[02:34] (154.32s)
кажется, первое приложение, в котором
[02:35] (155.64s)
появилась функциональность MSP. Ну,
[02:37] (157.40s)
неудивительно, потому что это приложение
[02:39] (159.24s)
сделано антроopic. Оно удобно, чтобы
[02:41] (161.28s)
делать любые LLM задачи у себя на
[02:42] (162.92s)
компьютере. Наверное, только кроме
[02:44] (164.40s)
кодинга. для разработки всё-таки лучше
[02:46] (166.16s)
курсор. Ну и есть также множество других
[02:48] (168.08s)
Open source, MCP клиентов, которые
[02:50] (170.12s)
интегрируются с помощью апи ключей. Я не
[02:52] (172.32s)
очень рекомендую такие приложения. Чуть
[02:54] (174.24s)
позже расскажу, почему. Как подключить
[02:56] (176.08s)
MCP сервер к курсору? Это сделать
[02:57] (177.96s)
достаточно просто. Открываешь курсор,
[02:59] (179.64s)
выбираешь любой проект, нажимаешь
[03:01] (181.36s)
Preferences, курсор Settings, переходишь
[03:03] (183.76s)
на вкладку MCP, нажимаешь Addne New
[03:06] (186.80s)
Global MCP Server, вставляешь туда JSON,
[03:10] (190.32s)
скопированный из GitHub репозитория
[03:12] (192.44s)
нужного тебе сервера. Например, давайте
[03:14] (194.88s)
вставим MCP сервер Playwrite. Он нужен,
[03:17] (197.80s)
чтобы работать с браузером,
[03:18] (198.88s)
автоматизированно, например, дебажить
[03:21] (201.04s)
front-end или искать информацию в
[03:23] (203.80s)
интернете. Открываем его страницу в
[03:25] (205.56s)
GitHub, копируем, вставляем. Проверяем,
[03:27] (207.76s)
что MCP сервер загорелся зелёненьким,
[03:29] (209.84s)
значит, он запущен и готов к работе. Всё
[03:32] (212.24s)
ок. Пропишем в чате. Открой сайт nb.com
[03:35] (215.40s)
и посмотри стоимость жизнь в Лондоне,
[03:37] (217.04s)
используя Playwright. Ага, открылась,
[03:39] (219.16s)
данные получены. Как подключить MCP
[03:41] (221.32s)
сервер Cloud Desktop? А здесь тоже всё
[03:43] (223.80s)
почти то же самое. Нажимаем Cloud
[03:45] (225.68s)
Settings, Developer, Edit, Config.
[03:48] (228.12s)
Меняем содержимое Jon файлы аналогичным
[03:50] (230.44s)
образом. Сохраняем, перезапускаем.
[03:52] (232.16s)
Вуаля. И Playri тоже работает. Как
[03:54] (234.64s)
работают MCP-серверы? Всё устроено не
[03:56] (236.68s)
суперсложно. После подключения JSON
[03:58] (238.64s)
конфигурации MCP-клиент выкачивает код
[04:01] (241.08s)
сервера и запускает его у тебя на
[04:03] (243.20s)
компьютере локально. Клиент шлёт в него
[04:05] (245.08s)
инициализирующую команду. Если всё
[04:07] (247.08s)
хорошо, то клиент получает в ответе
[04:09] (249.08s)
список тулзов, ромтов и ресурсов,
[04:11] (251.92s)
доступных в данном сервере. Затем
[04:14] (254.20s)
MCP-клиент при каждом новом запросе CLM
[04:16] (256.92s)
прописывает дополнительный блок, в
[04:19] (259.04s)
котором он указывает все доступные
[04:21] (261.72s)
действия, которые поддерживают
[04:23] (263.44s)
подключённые MCP-серверы. Также в этом
[04:25] (265.56s)
блоке указываются доступные параметры,
[04:27] (267.84s)
которые нейронка может указать, если
[04:30] (270.08s)
хочет вызвать какой-нибудь инструмент.
[04:31] (271.96s)
Ну и самое главное, указывается описание
[04:34] (274.40s)
каждого действия инструмента, чтобы
[04:36] (276.40s)
нейронка понимала, когда и зачем
[04:39] (279.40s)
использовать эту лзу. Например,
[04:41] (281.32s)
рассмотрим параметры функции Brave
[04:43] (283.04s)
Search Brave Web Search. Здесь видно,
[04:45] (285.72s)
что метод принимает на вход поисковую
[04:48] (288.08s)
строку и параметры погинации результата.
[04:50] (290.52s)
Как обычно, это офсет или отступ и число
[04:53] (293.52s)
результатов. Также мы видим текстовое
[04:55] (295.24s)
описание метода, чтобы модель понимала,
[04:57] (297.20s)
когда и как вызывать этот инструмент. В
[05:00] (300.16s)
случае, если модель решает вызвать
[05:01] (301.84s)
инструмент, то она возвращает новый блок
[05:04] (304.28s)
Tool Calls, в котором содержится список
[05:06] (306.48s)
вызываемых инструментов. В них
[05:08] (308.20s)
указывается название самих инструментов
[05:10] (310.84s)
плюс параметры, которые нужно передать
[05:13] (313.00s)
при вызове. Затем MCP-клиент послушно
[05:15] (315.32s)
выполняет эти инструкции. Он вызывает
[05:17] (317.56s)
инструмент, получает результат и в
[05:19] (319.80s)
следующем запросе к Лэмке передаёт новый
[05:22] (322.56s)
блок с результатами. Этот блок просто
[05:24] (324.52s)
добавляется в список сообщений. В
[05:26] (326.40s)
качестве роли указывается ТO, а в
[05:28] (328.52s)
контенте прописывается результат вызова.
[05:31] (331.00s)
Где найти готовые MCP-серверы? Их легко
[05:33] (333.20s)
можно найти в интернете. Есть парочка
[05:35] (335.00s)
популярных репозиториев на GitHub, в
[05:36] (336.80s)
которых собраны ссылки на множество
[05:39] (339.48s)
проверенных и качественных MCP-серверов.
[05:42] (342.00s)
Я обычно смотрю вот в этих двух, ссылки
[05:43] (343.56s)
будут в описании. Я там беру все свои
[05:45] (345.28s)
MCP серверы. Вот мой топ лучших MCP
[05:47] (347.56s)
серверов. Первое: Sequential Thinking.
[05:49] (349.44s)
Он делает из обычной модели думающую за
[05:51] (351.80s)
счёт механизма Chain of Thought. по сути
[05:54] (354.00s)
предоставляет модели строить цепочки
[05:56] (356.04s)
рассуждений, пересматривать и
[05:57] (357.64s)
возвращаться к разным мыслям. Полезен в
[05:59] (359.56s)
сложных задачах. Для примера такой
[06:01] (361.08s)
задачи можем глянуть подсчёт количества
[06:02] (362.96s)
букв R в словери. Как видим, без этого
[06:05] (365.76s)
MCP-сервера недумающие нейронки не
[06:08] (368.28s)
справляются. Они получают неверный ответ
[06:10] (370.16s)
два. Но если мы подключимся к thinking,
[06:12] (372.40s)
то результат получается, который нам
[06:14] (374.16s)
нужен. Второе. Context 7 - это поиск по
[06:16] (376.20s)
любым документациям и библиотекам. В нём
[06:18] (378.56s)
можно искать информацию по ключевым
[06:20] (380.32s)
словам, названиям библиотек, смотреть
[06:22] (382.96s)
какие-то отдельные части документации.
[06:24] (384.96s)
Без этого MCP твоя нейронка рано или
[06:26] (386.84s)
поздно начнёт выдумывать какие-то
[06:28] (388.24s)
классы, методы, несуществующие
[06:30] (390.52s)
переменные, параметры и так далее. Если
[06:32] (392.88s)
ты подключишь этот MCP-сервер, то такой
[06:35] (395.24s)
проблемы не будет. Давайте попробуем
[06:36] (396.72s)
сделать пример демки Думма без этого
[06:39] (399.00s)
сервера и с ним. Как видно, при
[06:40] (400.96s)
использовании сервера нейронка была
[06:42] (402.64s)
более уверена в своих силах и решила
[06:44] (404.24s)
использовать более продвинутый подход-
[06:46] (406.20s)
это подключить библиотеку 3GS и не
[06:50] (410.12s)
писать свой 3D-движок с нуля. Результат
[06:52] (412.44s)
получился более качественным. Playri -
[06:54] (414.60s)
это управляемый браузер. Он может
[06:56] (416.60s)
открывать любые сайты, кликать на
[06:58] (418.28s)
кнопки, переходить по ссылкам, заполнять
[07:00] (420.60s)
формы. У него есть как минимум два
[07:02] (422.56s)
применения. Первое - это тестировать
[07:04] (424.92s)
твой фронт-endнд, дебажить, проверять,
[07:06] (426.76s)
что нет в ошибок в консоли и так далее.
[07:08] (428.76s)
Второе - это поиск информации в
[07:10] (430.44s)
интернете. Например, в связке с
[07:12] (432.04s)
поисковым MCP-сервером, типа Brave
[07:14] (434.32s)
Search, ты можешь искать сайты,
[07:15] (435.72s)
переходить на них и собирать из них
[07:17] (437.80s)
сырую информацию. И последние два - это
[07:19] (439.80s)
Моск для Cloud Desktop, а не курсор,
[07:22] (442.08s)
потому что в курсоре они по сути есть по
[07:24] (444.32s)
умолчанию. Это F system, позволяет
[07:26] (446.88s)
работать с файлами, изменять, сохранять,
[07:28] (448.72s)
удалять и так далее. Позволяет
[07:30] (450.48s)
ограничить доступ к различным папкам,
[07:32] (452.48s)
чтобы нейронка не сделала RMRF
[07:35] (455.44s)
на всём твоём диске. Второе - это вGВ.
[07:37] (457.56s)
даёт запускать любые команды в
[07:39] (459.04s)
терминале, отслеживает статус
[07:40] (460.64s)
выполнения, запускать, собирать твои
[07:42] (462.52s)
проекты. Очень полезная штука. Как
[07:44] (464.32s)
создать свой MCP сервер? Для этого мы
[07:46] (466.44s)
можем использовать официальные SDК на
[07:48] (468.48s)
любом языке программирования под
[07:49] (469.88s)
названием Fast MCP. Например, на Питоне
[07:52] (472.16s)
достаточно подключить зависимость MCP,
[07:54] (474.76s)
импортировать fast MCP, реализовать
[07:57] (477.20s)
методы через аннотацию Tool, ресурс,
[08:00] (480.00s)
промт. Шаблон простого MCP-сервера лежит
[08:02] (482.40s)
у меня в телеграме по ссылке в описании.
[08:04] (484.44s)
Проблемы в работе с MCP и как их решить.
[08:06] (486.72s)
Иногда при работе с MCP возникают
[08:08] (488.36s)
сложности, и это реально боль. Вот те,
[08:10] (490.44s)
которые я встречал. Первое, без явной
[08:12] (492.52s)
просьбы курсор или другой MCP-клиент не
[08:15] (495.16s)
вызывает нужный тебе сервер. Такое часто
[08:17] (497.52s)
случается, если подключить КонEx 7 или
[08:20] (500.08s)
Sequential Thinking. Алонка по умолчанию
[08:22] (502.36s)
считает, что она и так всё знает и
[08:24] (504.08s)
просто не трогает эти NCP-серверы. Есть
[08:26] (506.36s)
два способа, как решить эту проблему.
[08:28] (508.12s)
Первый, в каждом запросе к LM явно
[08:30] (510.36s)
указывает, что ты хочешь использовать
[08:32] (512.08s)
тот или иной сервер. И второй-
[08:34] (514.04s)
использовать rules, доступный в IDE
[08:35] (515.96s)
курсор. Мы можем прописать, чтобы он
[08:37] (517.84s)
явно использовал sequential thinking и
[08:40] (520.12s)
context 7 для получения актуальной
[08:42] (522.32s)
документации. Вторая проблема, она уже
[08:44] (524.36s)
немножко посерьёзнее. MCP-серверы тратят
[08:47] (527.04s)
дохренищ токенов, если ты работаешь по
[08:49] (529.40s)
своему апи ключу. Почему так? Сейчас
[08:51] (531.56s)
расскажу, как выглядит цикл работы LLM +
[08:54] (534.36s)
MCP. Сначала пользователь пишет свой
[08:56] (536.48s)
запрос к LM и указывает весь список
[08:59] (539.04s)
доступных инструментов. Затем в ответе
[09:01] (541.28s)
LLM говорит нам вызвать такие-то
[09:03] (543.20s)
MCP-серверы. Наш MCP-клиент вызывает их,
[09:05] (545.88s)
получает результат и вызывает следующий
[09:08] (548.36s)
автоматизированный запрос LLM, в котором
[09:11] (551.04s)
передаёт результат и весь наш набор
[09:13] (553.32s)
MCP-серверов, плюс всю историю запросов.
[09:16] (556.52s)
До этого LLM решает, что же нам делать
[09:18] (558.88s)
дальше. Вызвать какой-то инструмент. Мы
[09:20] (560.76s)
его опять вызываем, получаем результат и
[09:23] (563.08s)
передаём в Лэмку ещё один запрос. Также
[09:25] (565.44s)
в нём содержатся все доступные
[09:27] (567.52s)
инструменты, все предыдущие результаты
[09:29] (569.92s)
инструментов, все предыдущие сообщения в
[09:32] (572.36s)
диалоге. О'кей, Лэмка нам ответила, что
[09:34] (574.56s)
всё готово, задача выполнена. В итоге
[09:36] (576.60s)
получилось, что вместо одного вызова,
[09:38] (578.80s)
который бы вернул нам просто код двух
[09:40] (580.68s)
файлов, мы сделали три последовательных
[09:43] (583.12s)
вызова нейронки с увеличенным
[09:44] (584.80s)
содержимом. Каждый раз мы передавали
[09:46] (586.60s)
список инструментов. На больших задачах
[09:48] (588.56s)
и сложных проектов стоимость такого
[09:50] (590.16s)
агента с MCP-серверами значительно
[09:52] (592.16s)
превышает обычную переписку с LM-чатом.
[09:54] (594.64s)
Также нужно учесть, что модели нейронак,
[09:56] (596.76s)
заточенные под программирование тоже не
[09:58] (598.92s)
из дешёвых, поэтому нужно быть очень
[10:00] (600.68s)
осторожным с MCP-клиентами, которые
[10:02] (602.52s)
используют твои АИ ключи, например, Cli.
[10:04] (604.96s)
Именно поэтому я рекомендую использовать
[10:06] (606.52s)
такие безлимитные MCP-клиенты, как Cursр
[10:09] (609.20s)
или Clodes в них ты платишь
[10:11] (611.00s)
фиксированную сумму в месяц и получаешь,
[10:13] (613.24s)
по сути, неограниченное количество
[10:14] (614.68s)
вызовов нейронок. Итоги. MCP-сервер -
[10:17] (617.08s)
это действительно мощное оружие для
[10:18] (618.76s)
любого пользователя LLM. Оно ускоряет
[10:20] (620.84s)
работу с нейротями в разы, позволяет
[10:22] (622.68s)
создавать сложные связки инструментов,
[10:24] (624.48s)
организовывая работу на полуавтомате.
[10:26] (626.40s)
Уверен, что вся эта экосистема MCP
[10:28] (628.16s)
сервера будет только развиваться, и мы
[10:29] (629.64s)
увидим ещё более невероятные вещи. А
[10:31] (631.56s)
пока что подписывайтесь. Здесь я буду
[10:33] (633.28s)
делиться опытом использования и
[10:34] (634.92s)
инструментов, обзорами всяких штук и
[10:37] (637.12s)
историями о своих небольших проектах. А
[10:39] (639.32s)
также подписывайтесь на мой
[10:40] (640.48s)
Telegram-канал. Там я пишу свои мысли,
[10:42] (642.92s)
небольшие обзоры на то, что успел
[10:44] (644.52s)
пощупать и результаты своих персональных
[10:46] (646.60s)
проектов. Ссылка в описании.