hackernoon-top-story artificial-intelligence software-development tech-stories ai-tools llms mcp-architecture what-is-mcp tool-calling

MCP Demystifified: Что на самом деле проходит через проволоку ??

23 июня 2025 г.

Все рассекают MCP, как будто это розеттский камень ИИ. Диаграммы! Белые пейзажи! Мыслители, делающие тиктоки!

Но где, мои дорогие друиды данных, настоящие пакеты? Вот что заставляет меня с ума:Никто не показывает фактические пакеты.

Это все равно, что пытаться выучить операцию на мотивационном плакате. Конечно, теоретическая структура *вдохновляет *, но я хочу увидеть кровь и кишки! Где сырой json? Где свалки stdin/stdout? Как я должен оживить свое творение, когда я даже не вижу молнии?

Попытка выучить протокол без проводных дамп - это все равно, что пытаться выучить ограждение от PowerPoint.

Дайте мне электроны или дайте мне смерть.

Теперь, когда у нас есть наша мантра, давайте копаем!

Это ваша бизнес -модель?

Ваш бизнес -план MCP:

✅ Узнайте MCP
❓ ??? (... происходит чудо ...)
💰 Прибыль

Звучит знакомо? Конечно! Это стартап, эквивалентный превращению свинца в золото. Алхимия, но с гораздо большим количеством JSON.

К счастью…

#Ты не одинока!

Похоже, что повреждения чернил были пролиты по этому так называемому протоколу контекста модели. Все говорят о развивающихся LLMS, вызове инструментов, вызовах функций, двунаправленной этой и возможностях. Я, конечно, не исключение. Но одна вещь продолжала косо в моем мозге, когда я прогуливался по этому веселому пути теории и абстракции:

"Как это выглядит на проводе ???"

Конечно, весь протокол задокументирован наModelContextProtocol.io, но я не хочу философии. Я хочувидетьбиты. Я хочу почувствовать, что доктор Франкенштейн ухаживал за моим големом, молнией и всем остальным. Не пробираясь через еще одну семантическую сток сена неясной грамматики со вкусом BNF.

Горе я, был простым пребыванием среди потенциальных, до тех пор, пока я не раскрыл его, так же!

Первоначальные наблюдения с поля

MCP очень, очень новый. Кровоточащий край. Возможно, все еще кровоточит. Возможно, однажды будут написаны целые книги о его внутренней политике, как о какой -то цифровой конституционной конституции. И давайте будем реальными - эта книга будет продаваться как NFT.

Но сейчас одна вещь выделяется прежде всего:

Инструментальный вызов - это все, что вам нужно

Если мы увеличиваем путь, в этом сингл, вариант критического использования -призыв инструмента- мы можем игнорироватьмногопух. Мы можем упростить, пока не смотрим на красивый скелет системы: всего четыре типа сообщений для вывода и три для ввода. (Мы объясним, почему цифры не совпадают чуть позже.)

initialize
initialized
tools/list
tools/call
(и 3resultsэто возвращается)

Да, вот и все. Вы можете понять весь протокол, зная об этих семи сообщениях.

Пример погоды (отModelContextProtocol.io)

Мы будем использоватьweather.py- простой пример MCP -сервера, который позволяет запросить прогноз и предупреждать данные. Вы можете найти это в их GitHub здесь: [[https://github.com/modelcontextprotocol/quickstart-resources/blob/main/weather-server-python/weather.py]

Давайте поговорим о том, что на самом деле происходит «на проволоке», когда вы разговариваете с этой штукой.

Первым: MCPТранспорт агностик.Это означает, что спецификация не заботится о том, как вы подключаетесь к серверу. Https? Веб -розетки? Названный труб? Поступив в древний кабель вампира Ethernet? Не имеет значения.

На практике наиболее распространенным методом является запуск сервера как подпроцесс и общениеstdinиstdoutПолем Это дает вам хороший маленький канал личного общения. (Технически полнодуплекс, но если вы добавитеstderr, мы будем называть это 1,5-дуплексом, чтобы быть милым).

Как текут сообщения

MCP использует JSON-RPC 2.0 через проволоку. Это дает вам протокол запроса/ответа, а также уведомления.

Каждое сообщение отправляется как одно на строку JSON. Это как сервис цифровой телеграммы, где каждая строка представляет собой полный пакет смысла.

Это в спецификации? Вроде; не совсем. Спецификация оставляет его открытым. Но этот json с новой линией-идиома по умолчанию.

Миф о "stdin/stdout считается вредным"

Да, вы можете найти несколько драматических сообщений в блоге, утверждающих, что этот шаблон «опасен» или «ненадежный». Может быть, они даже написали это в All-Caps: «Общение Stdin/Stdout MCP считалось вредным».

Кажется страшным! Мы не хотим начинать огонь в лаборатории, не так ли? Почему люди говорят это, если бы это не было правдой?

Видите ли, в Le Olden, более длительные линии могут вызвать переполнение буфера (привет, Morris Worm). К счастью, большинство современного программного обеспечения не страдает от этой проблемы (так же сильно! Пальцы скрещены!). Современные анализаторы JSON и быстрые и устойчивые. Хотите отправить предупреждение о погоде на 256 МБ? Действуй. Просто ... может быть, не делай этого каждую секунду.

Эти предупреждения обычно поступают от людей вручную подключаемых файловых дескрипторов в C. Вы этого не делаете. Вы используете Python. В частности,subprocessмодуль, который построен именно для такого рода задачи.

# fork off an MCP subprocess

import subprocess as sp

# Redirect stderr to /dev/null
stderr = sp.DEVNULL

# Start the weather.py process
process = sp.Popen(
    ["uv", "run", "weather.py"],
    stdin=sp.PIPE,
    stdout=sp.PIPE,
    stderr=stderr
)

Легко, верно? Весь местный питон. Нет дополнительных пакетов. Батареи включены.

АsubprocessМодуль заменяет потоки ввода -вывода ребенка на трубы, давая вам полное владение. Мы также можем отправить наши новые сигналы процесса, если мы так желаем.

Теперь мы наконец готовы сделать науку о протоколе, какПравильный цифровой некромант!

Сютный поворот: смущающе просто

MCP, во всех своих регалиях по предприятию и пейдштуру, является только этим:

YOU: "Hello, I speak robot."
SERVER: "Delightful. I also speak robot."
YOU: "Excellent, we both can speak robot!"
YOU: "What tricks can you do?"
SERVER: "I can juggle and summon storms."
YOU: "Storm, please!"
SERVER: "⛈️ As you wish."

Это буквально это. Весь этот протокол - просто очень формальный способ попросить кого -то сделать что -то и получить подтверждение того, что они это сделали.

Остальное-это просто церемония корпоративного уровня и блеск вокруг этого прекрасно простых рукопожатия.

Вот и все.Семь вежливых обменов.

Объединение монстра вместе: рабочий прототип

Пора испачкать руки. Мы собираемся создать погодный сервер и допросить его, как подходящий сумасшедший ученый.

Совет № 1: Лучший способ понять протокол - это злоупотреблять им до тех пор, пока он не кричит, а затем исправляет его, пока он не сотрудничает. Работает на коде, комнатных растениях и иногда старого Subarus.

Совет № 2: Если вы пытете в свои LLM, я не буду нести ответственность за то, что происходит с вами в последующие времена, когда ИИ покончил!

Шаг 1: Призыв нашего цифрового миньона


# Behold! We create life!
# (fork off an MCP subprocess)

import subprocess

# Start the weather.py process
# Use `uv run` to execute the script in the uv environment
# Redirect stdin, stdout to PIPE for communication
# Redirect stderr to DEVNULL to suppress error messages

process = subprocess.Popen(
    ["uv", "run", "weather.py"],
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    stderr=stderr)

# Behold! We create life!
process = subprocess.Popen(
    ["uv", "run", "weather.py"],
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    stderr=subprocess.DEVNULL  # Silence the screams
)

АsubprocessМодуль заменяет потоки ввода -вывода ребенка на трубы, давая вам полный контроль над разговором. Это прекрасно просто: теперь у вас есть специальный дочерний процесс в вашем Beck and Call, готовый выполнить все, что вы бросите на него.

Нужно стать агрессивным? Вы даже можете отправить сигналы, чтобы по -настоящему показать, кто босс.

Самая лучшая часть? В нормальных условиях, когда родительский процесс уходит, ребенок уходит с корабля - поэтому вам не нужно беспокоиться о процессах зомби, загромождающих вашу систему (ну, в основном).

Быстро в стороне: Вы заметите, что мы используемuvчтобы породить процесс. Это не требуется, ноuvбыстро становится золотым стандартом для современного инструмента Python. Если вы еще не проверили это, вы абсолютно должны-это переломный переход.

Если вы все еще используетеpip, нам нужно поговорить.

Шаг 2: Неловкое первое свидание

Каждая хорошая связь начинается с взаимной идентификации. Мы начнем с объявления себя (как джентльмен):


# Define the initialize request
init_request = {
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-03-26",
    "capabilities": {},
    "clientInfo": {
      "name": "MyMCPClient",
      "version": "1.0.0"
    }
  }
}

Это нашОткрытие салвов- Первый пакет, который мы отправляем, чтобы установить общение. Он сообщает серверу три важных вещах: мы говорим MCP, какую версию мы используем, и какие возможности мы приносим в таблицу.

Вы заметите, что это следует за форматом JSON-RPC 2.0, и это будет последовательным на протяжении всего нашего разговора с сервером. Каждое сообщение, каждый ответ-все JSON-RPC 2.0.

Давайте отпустим это.


import json


def send_mcp_request(process, request):
    """Sends a JSON-RPC request to the subprocess's stdin."""
    json_request = json.dumps(request) + '\n' # Add newline delimiter
    process.stdin.write(json_request.encode('utf-8'))
    process.stdin.flush() # Ensure the data is sent immediately


# 1. Send the initialize request
print("Sending initialize request...")
send_mcp_request(process, init_request)

Мы должны увидеть этот вывод:


Sending initialize request...

Теперь давайте послушаем, что сервер говорит обо всем:


def read_mcp_response(process):
    """Reads a JSON-RPC response from the subprocess's stdout."""
    # Assuming the server sends one JSON object per line
    line = process.stdout.readline().decode('utf-8')
    if line:
        print("     . . . len is", len(line))
        return json.loads(line)
    return None


print("Sending initialized request...")
send_mcp_request(process, notified_request)

Сервер, будучи вежливым, представляет себя обратно:


     . . . len is 266
Received response after initialization:{'id': 1,
 'jsonrpc': '2.0',
 'result': {'capabilities': {'experimental': {},
                             'prompts': {'listChanged': False},
                             'resources': {'listChanged': False,
                                           'subscribe': False},
                             'tools': {'listChanged': False}},
            'protocolVersion': '2025-03-26',
            'serverInfo': {'name': 'weather', 'version': '1.9.4'}}}

Перевод: «Здравствуйте! Я сервер погоды, я не буду случайным образом изменить свои способности в середине конверта, и я определенно не буду призвать вас».

Итак, что на самом деле нам рассказывает сервер?Это информация о версии протокола обмена и основные детали, новозможностиРаздел - настоящий приз.

Мы игнорируем возможности для этой демонстрации, но проверьте это: мымогПодпишитесь на «ListChanged» события, если наш сервер был типом для добавления или динамического удаления инструментов. На самом деле в протоколе MCP прячутся маленький маленький паб/субсистема - вы можете прослушать все виды событий. Наш сервер Weather.py слишком прост для любого из этих причудливых вещей, но он есть, если вам это нужно.

То же самое с «подсказками» и «ресурсами» - мы полностью пропускаем их. Конечно, мы могли бы бросить нашу собственную реализацию, но это упускает смыслРазделение APIПолем Вся идея заключается в том, что разные системы обрабатывают разные проблемы, поэтому вам не нужно изобретать каждое колесо. Вы можете выбирать, какие части протокола реализовать, но если вы хотите хорошо играть с другими инструментами MCP, вам лучше придерживаться спецификации.

Хорошо, мы связаны и готовы к рок, верно?

Неправильный.

Сервер все еще сидит там, нажимая на цифровую ногу, ожидая, когда мы завершит рукопожатие. Нам нужно отправить сигнал «Все хорошо на нашем конце»:


notified_request = {
  "jsonrpc": "2.0",
  "method": "notifications/initialized"
}

Обратите внимание на отсутствиеidполе? Это способ JSON-RPC сказать «Огонь и забыть»-никакого ответа не ожидалось или не требуется. В отличие от обычного танца запроса/ответа, который мы делали, этоуведомлениеПолем Думайте об этом как о отправке пакета ACK: «Эй, сервер, я готов к переворот!»

Нетidозначает: «Не отвечайте, я верю, что вы знаете, что делать с этой информацией». Как давать комплименты вашей кошке.

Тем временем ... Вернуться на ранчо ... (Вернемся к истории!)

Помните, что сервер, будучи разумно вежливым, уже ответил с манифестом своих способностей. Мы хотим одобрительно кивать.

Итак, давайте подтвердим:Да, мы действительно готовы к вечеринке.

# yes we are indeed ready to party

# Acknowledge the server so it knows we approve
print("// Sending initialized request...")
send_mcp_request(process, notified_request)

Теперь сервер знает, что начинает ожидать запросов.

Шаг 3: «Покажи мне, что ты получил»

Время увидеть, какие игрушки принесли этот сервер на детскую площадку:


tools_list_request = {
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/list",
  "params": {
  }
}


# 2. Send the tools/list request
print("// Sending tools/list request...")
send_mcp_request(process, tools_list_request)

Мы получаем именно тот результат, который мы ожидали ... идеально!


// Sending tools/list request...

Теперь давайте прочитаем результаты ... время, чтобы увидеть, какие сокровища мы обнаружили:


# Read the server's response to the tools/list request                                                                                    
tools_list_response = read_mcp_response(process)
print("// Received tools list response:", end='')
pprint(tools_list_response)

И наш сервер с гордостью отображает свои товары: прогнозы, оповещения и другие метеорологические вреда.


     . . . len is 732
// Received tools list response:{'id': 2,
 'jsonrpc': '2.0',
 'result': {'tools': [{'description': 'Get weather alerts for a US state.\n'
                                      '\n'
                                      '    Args:\n'
                                      '        state: Two-letter US state code '
                                      '(e.g. CA, NY)\n'
                                      '    ',
                       'inputSchema': {'properties': {'state': {'title': 'State',
                                                                'type': 'string'}},
                                       'required': ['state'],
                                       'title': 'get_alertsArguments',
                                       'type': 'object'},
                       'name': 'get_alerts'},
                      {'description': 'Get weather forecast for a location.\n'
                                      '\n'
                                      '    Args:\n'
                                      '        latitude: Latitude of the '
                                      'location\n'
                                      '        longitude: Longitude of the '
                                      'location\n'
                                      '    ',
                       'inputSchema': {'properties': {'latitude': {'title': 'Latitude',
                                                                   'type': 'number'},
                                                      'longitude': {'title': 'Longitude',
                                                                    'type': 'number'}},
                                       'required': ['latitude', 'longitude'],
                                       'title': 'get_forecastArguments',
                                       'type': 'object'},
                       'name': 'get_forecast'}]}}

Уго! Этомногоjson! Хорошо, давайте углубимся в хорошие вещи.

Увидеть этоtoolsмассив там? Это наша золотая линия - каждый объект представляет собой инструмент, который может вызвать LLM. (Сюжет поворот: мы тоже можем их назвать, что именно то, что мы делаем прямо сейчас!)

Забавный факт: поля «описания» - это то, как ваш LLM решает, какую функцию звонить. Думайте об этом как о Tinder для инструментов, а ваш AI смотрит на телефон, пытаясь решить, перейти ли влево или вправо

Одно интересное примечание: Openai изначально пытался назвать это «вызовом функции», а это ...техническиТочно, я полагаю. Но где -то на этом пути индустрия коллективно решила, что «инструменты» звучали круче (или, может быть, более доступной?), И теперь мы называем весь инструмент Dance «Calling».

Анатомия инструмента (обратите внимание, вот где живет магия):

имя: Фактическое имя функции - здесь не разрешено опечатки! Это окончательное, каноническое название инструмента; Мы будем использовать его для обозначения этого инструмента, когда мы его называем.
описание: Простой английский для LLM для чтения (это буквально то, на что смотрит ИИ, решая, использовать ли ваш инструмент)
inputschema: Схема JSON, определяя, какие параметры вам нужны
выходы: Явно отсутствует! Все просто возвращает «большую строку» и надеется на лучшее

Почему нет выходной схемы? Потому что мы все в основном возвращаем JSON, завернутый в струны и притворяемся, что это дизайнерское решение. Это как Дикий Запад, но с большим количеством беспокойства о безопасности.

Это на самом деле имеет смысл, когда вы рассматриваете эволюцию от «вызовы функции» до «инструментального вызова». Традиционные функции могут возвращать любой тип, в то время как инструменты командной строки Unix (что подразумевает именование) просто выплевывает текст. Конечно, это в основном JSON под капюшоном, поэтому под поверхностью все еще скрывается структура.

У некоторых моделей даже есть переключатели, чтобы принудительно выходить вывод JSON, поэтому теоретически ваш LLM может ожидать структурированные данные каждый раз. Опять же, инструменты могут вернуть простой текст, CSV, HTML или действительно что угодно. Многомодальные модели могут даже возвращать аудио, изображения, видео или живые каналы обнаружения объектов-возможности удивительно хаотичны.

Хорошо, у нас загружен наше набор инструментов. Давайте сделаем наш первый инструмент MCP!

Шаг 4: момент истины

В любом случае, у нас есть список инструментов, что теперь? Позвоним одним!

Мы выбираем инструмент. Давайте выберемget_alertsЧтобы сделать вещи простыми, так как нам не нужна широта и долгота. Если бы у нас были данные GPS,get_forecastбыл бы лучшим выбором.


tools_call_request = {
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
        "name": "get_alerts",
        "arguments": {
            "state": "TX"
        }
    }
}

Я выбрал Техас, потому что там все больше, включая погодные катастрофы.

Подождите, держитесь - почему это «инструменты/вызов», а не «инструмент/вызов»? Я имею в виду, мы звоняемодинИнструмент, верно?

Хорошо, конечно, «инструмент/звонок» будет звучать более естественным на английском языке, но, по -видимому, согласованность с другими конечными точками выигрывает. Кроме того, в спецификации говорится «инструменты/звонок», так что ... мы находимся в очереди, как хорошие маленькие разработчики.

Сейчас, когда все наши данные в ряду мы можем нажать большую красную кнопку.


# 3. Send the tools/call request                                                                                                          
print("// Sending tools/call request...")
send_mcp_request(process, tools_call_request)

# Read the server's response to the tools/call request                                                                                    
tools_call_response = read_mcp_response(process)
print("// Received tools call response:", end='')
pprint(tools_call_response)

[Beep Boop Boop](Это звук, который делает большая красная кнопка)

[Барабанная дробь, пожалуйста]

Сервер думает ... обработка ... и ... и ...

[И толпа сходит с ума!]

Вуаля! Данные реальной погоды материализуются. Оповещения, наводнения, торнадо, работы. Все обернуты в структурированный JSON, как и ваш терапевт, приказал: (подстриженно, никто не хочет видеть 11 страниц свалков JSON)


// Sending tools/call request...
     . . . len is 51305
// Received tools call response:{'id': 3,
 'jsonrpc': '2.0',
 'result': {'content': [{'text': '\n'
                                 'Event: Flood Advisory\n'
                                 'Area: Hidalgo, TX; Willacy, TX\n'
                                 'Severity: Minor\n'
                                 'Description: * WHAT...Flooding caused by '
                                 'excessive rainfall continues.\n'
                                 '\n'
                                 '* WHERE...A portion of Deep South Texas, '
                                 'including the following\n'
                                 'counties, Hidalgo and Willacy.\n'
                                 '\n'
                                 '* WHEN...Until 245 PM CDT.\n'
                                 '\n'
                                 '* IMPACTS...Minor flooding in low-lying and '
                                 'poor drainage areas.\n'
                                 '\n'
                                 '* ADDITIONAL DETAILS...\n'
                                 '- At 205 PM CDT, Doppler radar indicated '
                                 'heavy rain due to\n'
                                 'thunderstorms. Minor flooding is ongoing or '
                                 'expected to begin\n'
                                 'shortly in the advisory area. Between 2 and '
                                 '5 inches of rain\n'
                                 'have fallen.\n'
                                 '- Additional rainfall amounts up to 1 inch '
                                 'are expected over\n'
                                 'the area. This additional rain will result '
                                 'in minor flooding.\n'
                                 '- Some locations that will experience '
                                 'flooding include...\n'
                                 'Harlingen, Elsa, Edcouch, La Villa, Lasara, '
                                 'La Villa High\n'
                                 'School, Monte Alto, Jose Borrego Middle '
                                 'School, Satiago\n'
                                 'Garcia Elementary School, Edcouch Police '
                                 'Department, Edcouch\n'
                                 'City Hall, Edcouch Volunteer Fire '
                                 'Department, Edcouch-Elsa\n'
                                 'High School, Laguna Seca, Carlos Truan '
                                 'Junior High School,\n'
                                 'Elsa Police Department, Lyndon B Johnson '
                                 'Elementary School,\n'
                                 'Elsa Public Library, Olivarez and Lasara '
                                 'Elementary School.\n'
                                 '- http://www.weather.gov/safety/flood\n'
                                 "Instructions: Turn around, don't drown when "
                                 'encountering flooded roads. Most flood\n'
                                 '\n'
                                 'The next statement will be issued Tuesday '
                                 'morning at 830 AM CDT.\n',
                         'type': 'text'}],
            'isError': False}}

Победа!Обратите внимание, чтоisError: false- всегда проверяйте это поле, если вы не любите отлаживать загадочные неудачи в 3 часа ночи.

Выглядит хорошо! Мы получаем обратно чистые строковые данные (без потоковой передачи, чтобы усложнять вещи), что дает нам варианты. Мы могли бы анализировать данные о погоде и массировать их для LLM или просто передавать необработанный ответ и позволить модели выяснить его. Большинство реализаций идут с последним подходом - почему дополнительная работа, когда LLMS довольно хороши в структурированном тексту?

Но если вы создаете что-то сложное, предварительная обработка вывода инструмента может быть невероятно мощным. Вы можете отформатировать его, отфильтровать, объединить его с другими источниками данных или преобразовать именно в то, что нужно вашему приложению.

И это обертка!Мы успешно зарегистрировали сервер MCP, инициализировали подключение, назвали инструмент и обработали результаты. Весь танец MCP, от рукопожатия до поиска данных. Ваши ноги уже устали?

Полный Монти: ваш полный клиент MCP

Вот весь славный ритуал в одном круге вызова:

import subprocess
import json
from pprint import pprint

def send_mcp_request(process, request):
    json_request = json.dumps(request) + '\n'
    process.stdin.write(json_request.encode('utf-8'))
    process.stdin.flush()

def read_mcp_response(process):
    line = process.stdout.readline().decode('utf-8')
    return json.loads(line) if line else None

requests = {
    'init': {
        "jsonrpc": "2.0", "id": 1, "method": "initialize",
        "params": {
            "protocolVersion": "2025-03-26",
            "capabilities": {},
            "clientInfo": {"name": "MyMCPClient", "version": "1.0.0"}
        }
    },
    'initialized': {
        "jsonrpc": "2.0", "method": "notifications/initialized"
    },
    'list_tools': {
        "jsonrpc": "2.0", "id": 2, "method": "tools/list"
    },
    'call_tool': {
        "jsonrpc": "2.0", "id": 3, "method": "tools/call",
        "params": {"name": "get_alerts", "arguments": {"state": "TX"}}
    }
}

process = subprocess.Popen(
    ["uv", "run", "weather.py"],
    stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL
)

try:
    send_mcp_request(process, requests['init'])
    pprint(read_mcp_response(process))

    send_mcp_request(process, requests['initialized'])

    send_mcp_request(process, requests['list_tools'])
    tools = read_mcp_response(process)
    print("Available tools:", [t['name'] for t in tools['result']['tools']])

    send_mcp_request(process, requests['call_tool'])
    result = read_mcp_response(process)
    print("Weather alert received:", len(result['result']['content'][0]['text']), "characters")

finally:
    process.terminate()

Большое раскрытие

Вы только что создали клиент MCP, используя только стандартную библиотеку Python.

Нет фреймворков. Нет внешних зависимостей. Нет магии. Просто подпроцессовые трубы и JSON - те же инструменты, которые у вас были со времен Python 2.7. Это «готово к производству»? Честно? Не совсем ... но это удивительно близко. Иногда самые простые решения являются самыми пуленепробиваемыми.

Это грязный секрет каждой модной интеграции MCP, которую вы когда -либо видели. Будь то Клод, разговаривая с вашей базой данных, GPT-4 называет ваши API или какую-то стартап «Революционная платформа рабочего процесса искусственного интеллекта»-на все это, это только это:

Процесс появления. Отправить JSON. Читайте Json. Повторить.

Это похоже на то, чтобы обнаружить «Волшебник страны Оз» - просто парень с действительно хорошей звуковой системой.

Ваши следующие шаги в безумие

Теперь, когда вы видели живот зверя (в коде), вы можете:

Построить пользовательские серверы MCPчто делает ваши приказы (больше не ждет кого -то другого, чтобы написать интеграцию)
Отладка MCP соединенияКак сетевой некромант, когда они неизбежно ломаются в худший возможный момент
Проектируйте лучшие инструментыточно зная, как LLMS потребляет ваши метаданные
Напишите лучшие инструментытак неотразимо описал, что ваши LLM влюбляются
Оптимизировать все из всегоПотому что вы понимаете накладные расходы протокола
Или простоАвтоматизируйте кормушку для кошекПолем Я не сужу.

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

Чудо во втором этапе вашего бизнес -плана? Это был ты все время.

Построите что -нибудь странное.

Хотите увидеть этот код в действии? Полный пример живет здесь: [[https://gitlab.com/-/snippets/4864350]

https://gitlab.com/-/snippets/4864350?embedable=true

Оригинал