Stateless MCP: Революция в безопасности и простоте AI-агентов

В мире искусственного интеллекта, где стандарты меняются со скоростью света, появление новой версии протокола может показаться лишь техническим обновлением. Однако для разработчиков, строящих надежные AI-агентные системы, это часто становится поворотным моментом. 31 июля 2026 года Simon Willison, один из ключевых мыслителей в области LLM, опубликовал статью, посвященную выходу спецификации MCP 2.0, официально названной "2026-07-28 Model Context Protocol". Это не просто очередная итерация; это фундаментальный сдвиг парадигмы, который вернул интерес к протоколу Model Context Protocol (MCP) после периода затишья, вызванного доминированием более гибких, но опасных подходов с доступом к терминалу.

Многие разработчики, включая самого Уиллисона, временно отошли от MCP в пользу "Skills" и прямого доступа агентов к оболочке (shell) и интернету через `curl`. Казалось, что свобода действий агента — это главное преимущество. Но на практике оказалось, что такая гибкость порождает серьезные проблемы с безопасностью, особенно когда речь идет о защите от утечек данных и инъекций промптов. Новый "без状态ный" (stateless) подход MCP 2.0 предлагает элегантное решение: он упрощает архитектуру, устраняя необходимость управления состоянием сессий на сервере, и делает протокол более предсказуемым и безопасным для корпоративного использования.

В этой статье мы подробно разберем, что такое Stateless MCP, почему это изменение критически важно для безопасности AI-приложений, и как новые инструменты, такие как `mcp-explorer` и `datasette-mcp`, позволяют разработчикам уже сегодня интегрировать этот протокол в свои проекты. Мы также рассмотрим практические примеры кода и реальные кейсы использования, чтобы показать, как этот переход влияет на повседневную разработку AI-агентов.

01Эволюция MCP: От сессий к состоянию

Чтобы понять масштаб изменений, introduced в MCP 2.0, необходимо回顾 (вернуться) к тому, как работал протокол в предыдущей версии, которую мы будем называть "Legacy MCP". Старая спецификация требовала двухэтапного взаимодействия между клиентом и сервером. Это был классический паттерн с сохранением состояния (stateful), который хорошо знаком разработчикам веб-приложений, но создает лишнюю сложность в контексте AI-агентов.

Первый шаг заключался в инициализации сессии. Клиент отправлял POST-запрос на эндпоинт `/mcp`, указывая версию протокола и информацию о клиенте. В ответ сервер генерировал уникальный идентификатор сессии (`Mcp-Session-Id`), который клиент должен был сохранить. Второй шаг — вызов самого инструмента — требовал повторного POST-запроса, в который обязательно нужно было включить заголовок `Mcp-Session-Id`. Без этого заголовка сервер не знал, к какой именно сессии относится запрос, и не мог предоставить доступ к контексту, установленному на первом шаге.

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

Новая спецификация Stateless MCP полностью устраняет эту необходимость. Теперь весь контекст, включая информацию о клиенте и версию протокола, передается в каждом отдельном запросе. Это делает каждый вызов инструмента независимым и самодостаточным. Давайте сравним код.

POST /mcp HTTP/1.1
Content-Type: application/json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-11-25",
    "capabilities": {},
    "clientInfo": {
      "name": "my-app",
      "version": "1.0"
    }
  }
}

POST /mcp HTTP/1.1
Mcp-Session-Id: 1868a90c-3a3f-4f5b
Content-Type: application/json
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "search",
    "arguments": {
      "q": "otters"
    }
  }
}

В приведенном выше примере видно, как второй запрос зависит от результата первого через заголовок сессии. Теперь посмотрим, как выглядит тот же вызов в Stateless MCP:

POST /mcp HTTP/1.1
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: search
Content-Type: application/json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "search",
    "arguments": {
      "q": "otters"
    },
    "_meta": {
      "io.modelcontextprotocol/clientInfo": {
        "name": "my-app",
        "version": "1.0"
      }
    }
  }
}

Как видите, вся необходимая информация передается в одном запросе. Версия протокола указывается в заголовке `MCP-Protocol-Version`, имя метода — в `Mcp-Method`, а информация о клиенте перемещена во вложенный объект `_meta` внутри параметров. Это не только чище, но и гораздо лучше подходит для построения масштабируемых веб-приложений, так как серверу больше не нужно поддерживать состояние сессий или беспокоиться о балансировке нагрузки между узлами.

02Почему безопасность требует отказа от произвольных команд

Интерес к MCP временно угас в 2025 году, когда на сцену вышли "Skills" и агенты с доступом к терминалу. Идея была проста: если дать агенту возможность запускать любые команды в оболочке и использовать `curl` для доступа к интернету, он сможет выполнить практически любую задачу без необходимости писать специфические инструменты для каждого действия. Однако этот подход оказался крайне рискованным.

Simon Willison неоднократно подчеркивал проблему безопасности, связанную с так называемой "Смертельной Тройкой" (Lethal Trifecta): доступ к файловой системе, доступ к сети и возможность выполнения произвольного кода. Когда пользователь смешивает инструменты, ответственность за предотвращение атак по извлечению данных (data exfiltration) ложится на самого пользователя. Агенты, работающие в открытой сети с произвольным выполнением команд, становятся легкой мишенью для инъекций промптов, которые могут заставить их отправить конфиденциальные данные на внешний сервер.

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

03mcp-explorer: Инструмент для интерактивного исследования

Одной из главных проблем при работе с новыми протоколами является отсутствие хороших инструментов для их тестирования и исследования. Simon Willison не нашел подходящего CLI-инструмента для интерактивного зондирования MCP-серверов, поэтому он использовал Codex (AI-ассистент для написания кода) для создания собственного инструмента — `mcp-explorer`.

`mcp-explorer` — это легковесный Python-инструмент командной строки, который работает по принципу "без состояния". Это означает, что вам не нужно даже устанавливать его глобально, чтобы попробовать. Вы можете запустить его напрямую через `uvx`, что делает его идеальным для быстрого тестирования.

Например, чтобы получить список доступных инструментов на демо-сервере `agentic-mermaid.dev`, достаточно выполнить следующую команду:

uvx mcp-explorer list https://agentic-mermaid.dev/mcp

Эта команда возвращает список инструментов, таких как `execute`, `describe_sdk`, `render_svg`, `render_ascii` и `render_png`. Каждый инструмент описан с указанием параметров и возвращаемых значений. Например, `render_svg` принимает строку с исходным кодом Mermaid и опциональные параметры, а возвращает объект с полем `ok` и SVG-строкой.

Для детального изучения конкретного инструмента, например `render_svg`, можно использовать команду `inspect`:

uvx mcp-explorer inspect render_svg

Эта команда выводит подробную информацию, включая JSON-схему входных и выходных данных. Это крайне полезно для разработчиков, которые хотят понять, как правильно формировать запросы к инструменту.

Для непосредственного вызова инструмента используется команда `call`. Например, чтобы отрендерить диаграмму в SVG, можно выполнить:

uvx mcp-explorer call \
  https://agentic-mermaid.dev/mcp \
  render_svg \
  -a source "graph TD; A-->B" \
  -a options '{"padding":24}'

Результатом будет JSON-объект с полем `svg`, содержащим SVG-код. Если добавить `| jq .svg -r` к команде, можно получить чистый SVG-код, который можно сохранить в файл или отобразить в браузере. Этот инструмент демонстрирует, как быстро можно освоить новый протокол, даже если большая часть кода была написана AI-ассистентом.

04datasette-mcp: Интеграция баз данных в AI-агентов

Вторым значимым проектом, вдохновленным Stateless MCP, является плагин `datasette-mcp` для платформы Datasette. Datasette — это популярный инструмент для публикации и исследования данных, часто используемый в научных и журналистских целях. Плагин добавляет эндпоинт `/-/mcp` к любому экземпляру Datasette, превращая его в MCP-сервер.

Плагин предоставляет три основных инструмента:

• list_databases() — возвращает список всех доступных баз данных.
• get_database_schema(database_name) — возвращает схему указанной базы данных.
• execute_sql(database_name, sql) — выполняет SQL-запрос. На данный момент этот инструмент работает только в режиме чтения (read-only), что является важным ограничением для безопасности.

Интеграция этих инструментов с AI-агентами, такими как ChatGPT или Claude, позволяет им выполнять SQL-запросы к вашим данным. Simon Willison протестировал это на зеркале своего блога, доступном по адресу `datasette.simonwillison.net/-/mcp`. Процесс подключения к ChatGPT и Claude потребовал некоторой настройки, но в итоге он успешно продемонстрировал, как агент может отвечать на сложные вопросы, выполняя несколько SQL-запросов.

Например, когда агенту был задан вопрос "what has Simon said recently about MCP?", он выполнил семь отдельных SQL-запросов, чтобы собрать достаточно информации для формирования полного ответа. Это демонстрирует мощь MCP: агент может самостоятельно планировать и выполнять сложные запросы к данным, не требуя от пользователя знания структуры базы данных.

05llm-mcp-client: Прямая интеграция в LLM-инструменты

Третий проект, представленный Simon Willison, — это плагин `llm-mcp-client` для инструмента `llm`. Этот плагин позволяет напрямую использовать MCP-серверы в качестве источников инструментов для LLM. Установка и использование плагина очень просты:

llm install llm-mcp-client
llm -T "MCP(\"https://datasette.simonwillison.net/-/mcp\")" count the notes

В этом примере агенту дается задача "count the notes" (посчитать заметки). Агент анализирует запрос, понимает, что нужно подсчитать количество опубликованных заметок и черновиков, и выполняет соответствующие SQL-запросы. В результате он возвращает точный ответ: 151 заметка. Этот процесс включает в себя цепочку рассуждений (reasoning trace), где агент объясняет свои действия, что делает процесс прозрачным и понятным для пользователя.

Simon планирует интегрировать эту функциональность непосредственно в ядро `LLM` в будущем, а также экспериментировать с MCP в других проектах, таких как `Datasette Agent` и `llm-coding-agent`. Это показывает, что MCP становится неотъемлемой частью экосистемы инструментов для работы с LLM.

06Что это значит на практике

Переход к Stateless MCP — это не просто техническое улучшение, это стратегическое решение, которое влияет на то, как мы строим AI-приложения. Вот ключевые выводы, которые следует учитывать разработчикам и архитекторам:

1. Безопасность прежде всего. Stateless MCP предлагает более безопасную альтернативу произвольному выполнению команд. Строгая типизация и отсутствие состояния сессий делают протокол более предсказуемым и легче поддающимся аудиту. Это критически важно для корпоративного использования, где риски утечки данных и инъекций промптов являются серьезными угрозами.
2. Простота масштабирования. Отсутствие необходимости управлять состоянием сессий упрощает архитектуру серверов. Это позволяет легче масштабировать MCP-серверы, используя стандартные методы балансировки нагрузки, без необходимости "прилипания" сессий к конкретным узлам.
3. Доступность для малых моделей. MCP-инструменты достаточно просты, чтобы ими могли управлять даже небольшие модели, работающие локально на ноутбуке. Это открывает возможности для создания автономных AI-систем, которые не зависят от облачных сервисов и могут работать в офлайн-режиме.
4. Быстрая интеграция. Появление таких инструментов, как `mcp-explorer` и `datasette-mcp`, значительно упрощает процесс интеграции MCP в существующие проекты. Разработчики могут быстро протестировать и внедрить протокол, не тратя время на разработку сложных клиентских библиотек с нуля.

Для разработчиков из России и других стран, где доступ к некоторым облачным сервисам может быть ограничен, локальный запуск MCP-серверов и клиентов становится особенно актуальным. Stateless MCP, благодаря своей простоте и отсутствию зависимости от сложных сессий, идеально подходит для таких сценариев. Вы можете развернуть MCP-сервер на локальном сервере или даже на Raspberry Pi, и агенты смогут взаимодействовать с ним без необходимости поддерживать сложные соединения.

В заключение, Stateless MCP 2.0 — это значительный шаг вперед для экосистемы AI-агентов. Он решает проблемы безопасности и сложности, которые были присущи предыдущим версиям, и открывает новые возможности для создания надежных, масштабируемых и доступных AI-приложений. Если вы еще не начали экспериментировать с MCP, сейчас самое время сделать это, используя новые инструменты и подходы, представленные в этой статье.

Источник: Simon Willison ↗